From f3ea201413e34e8a972248c12e5caf930047d7a2 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 4 Dec 2024 10:48:36 -0500 Subject: [PATCH 001/228] Add cpp parallel merge implementation --- tiledb/common/CMakeLists.txt | 1 + tiledb/common/algorithm/CMakeLists.txt | 43 ++ tiledb/common/algorithm/parallel_merge.cc | 393 ++++++++++++++++++ tiledb/common/algorithm/parallel_merge.h | 75 ++++ tiledb/common/algorithm/test/CMakeLists.txt | 32 ++ .../algorithm/test/compile_algorithm_main.cc | 34 ++ tiledb/common/algorithm/test/main.cc | 34 ++ .../algorithm/test/unit_parallel_merge.cc | 66 +++ .../thread_pool/producer_consumer_queue.h | 2 +- 9 files changed, 679 insertions(+), 1 deletion(-) create mode 100644 tiledb/common/algorithm/CMakeLists.txt create mode 100644 tiledb/common/algorithm/parallel_merge.cc create mode 100644 tiledb/common/algorithm/parallel_merge.h create mode 100644 tiledb/common/algorithm/test/CMakeLists.txt create mode 100644 tiledb/common/algorithm/test/compile_algorithm_main.cc create mode 100644 tiledb/common/algorithm/test/main.cc create mode 100644 tiledb/common/algorithm/test/unit_parallel_merge.cc diff --git a/tiledb/common/CMakeLists.txt b/tiledb/common/CMakeLists.txt index 032e2030482..e67cb2b4331 100644 --- a/tiledb/common/CMakeLists.txt +++ b/tiledb/common/CMakeLists.txt @@ -39,6 +39,7 @@ endif() # # Subdirectories # +add_subdirectory(algorithm) add_subdirectory(dynamic_memory) add_subdirectory(evaluator) add_subdirectory(exception) diff --git a/tiledb/common/algorithm/CMakeLists.txt b/tiledb/common/algorithm/CMakeLists.txt new file mode 100644 index 00000000000..95c1bd5a48b --- /dev/null +++ b/tiledb/common/algorithm/CMakeLists.txt @@ -0,0 +1,43 @@ +# +# tiledb/common/algorithm/CMakeLists.txt +# +# The MIT License +# +# Copyright (c) 2024 TileDB, 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. +# + +include(common NO_POLICY_SCOPE) +include(object_library) + +list(APPEND SOURCES + parallel_merge.cc +) +gather_sources(${SOURCES}) + +# +# `algorithm` object library +# +commence(object_library algorithm) + this_target_sources(${SOURCES}) + this_target_object_libraries(thread_pool) +conclude(object_library) + +add_test_subdirectory() diff --git a/tiledb/common/algorithm/parallel_merge.cc b/tiledb/common/algorithm/parallel_merge.cc new file mode 100644 index 00000000000..e49129fd24b --- /dev/null +++ b/tiledb/common/algorithm/parallel_merge.cc @@ -0,0 +1,393 @@ +/** + * @file parallel_merge.cc + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2018-2024 TileDB, 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. + * + * @section DESCRIPTION + * + * This file defines an implementation of a parallel merge algorithm for + * in-memory data. + */ + +#include "tiledb/common/algorithm/parallel_merge.h" +#include "tiledb/common/status.h" +#include "tiledb/common/thread_pool/thread_pool.h" + +#include + +using namespace tiledb::common; + +namespace tiledb::algorithm { + +template +using Streams = std::span>; + +void ParallelMergeFuture::block() { + while (merge_units_.pop().has_value()) + ; +} + +/** + * Represents one sequential unit of the parallel merge. + * + * Merges values in the ranges for each stream `s`, [starts[s], ends[s]]. + * This unit writes to the output in the range [sum(starts), sum(ends)]. + */ +struct MergeUnit { + std::vector starts; + std::vector ends; + + uint64_t num_items() const { + uint64_t total_items = 0; + for (size_t i = 0; i < starts.size(); i++) { + total_items += (ends[i] - starts[i]); + } + return total_items; + } + + uint64_t output_start() const { + uint64_t total_bound = 0; + for (size_t i = 0; i < ends.size(); i++) { + total_bound += starts[i]; + } + return total_bound; + } + + uint64_t output_end() const { + uint64_t total_bound = 0; + for (size_t i = 0; i < ends.size(); i++) { + total_bound += ends[i]; + } + return total_bound; + } + + bool operator==(const MergeUnit& other) const { + return (starts == other.starts) && (ends == other.ends); + } +}; + +template +struct span_greater { + bool operator()(const std::span l, const std::span r) const { + return std::greater()(l.front(), r.front()); + } +}; + +template +Status tournament_merge( + Streams streams, std::shared_ptr unit, T* output) { + std::vector> container; + container.reserve(streams.size()); + + // NB: we can definitely make a more optimized implementation + // which does a bunch of buffering for each battle in the tournament + // but this is straightforward + std::priority_queue, std::vector>, span_greater> + tournament({}, container); + + for (size_t i = 0; i < streams.size(); i++) { + if (unit->starts[i] != unit->ends[i]) { + tournament.push( + streams[i].subspan(unit->starts[i], unit->ends[i] - unit->starts[i])); + } + } + + size_t o = unit->output_start(); + + while (!tournament.empty()) { + auto stream = tournament.top(); + tournament.pop(); + + assert(!stream.empty()); + + output[o++] = stream.front(); + + if (stream.size() > 1) { + tournament.push(stream.subspan(1)); + } + } + + if (o == unit->output_end()) { + return Status::Ok(); + } else { + return Status_Error("Internal error in parallel merge"); + } +} + +template +MergeUnit split_point_stream_bounds( + Streams streams, uint64_t which, const MergeUnit& search_bounds) { + const T& split_point = streams[which][search_bounds.ends[which] - 1]; + + MergeUnit output; + output.starts = search_bounds.starts; + output.ends.reserve(streams.size()); + + for (uint64_t i = 0; i < streams.size(); i++) { + if (i == which) { + output.starts[i] = search_bounds.starts[i]; + output.ends.push_back(search_bounds.ends[i]); + } else { + std::span substream( + streams[i].begin() + search_bounds.starts[i], + streams[i].begin() + search_bounds.ends[i]); + + auto upper_bound = + std::upper_bound(substream.begin(), substream.end(), split_point); + output.ends.push_back( + output.starts[i] + std::distance(substream.begin(), upper_bound)); + } + } + + return output; +} + +enum class SearchStep { Stalled, MadeProgress, Converged }; + +template +struct SearchMergeBoundary { + Streams streams_; + uint64_t split_point_stream_; + uint64_t remaining_items_; + MergeUnit search_bounds_; + + SearchMergeBoundary(Streams streams, uint64_t target_items) + : streams_(streams) + , split_point_stream_(0) + , remaining_items_(target_items) { + search_bounds_.starts = std::vector(streams.size(), 0); + search_bounds_.ends.reserve(streams.size()); + for (const auto& stream : streams) { + search_bounds_.ends.push_back(stream.size()); + } + } + + MergeUnit current() const { + MergeUnit m; + m.starts = std::vector(search_bounds_.starts.size(), 0); + m.ends = search_bounds_.ends; + return m; + } + + SearchStep step() { + if (remaining_items_ == 0) { + return SearchStep::Converged; + } + + advance_split_point_stream(); + + MergeUnit split_point_bounds; + { + // temporarily shrink the split point stream bounds to indicate the split + // point + auto original_end = search_bounds_.ends[split_point_stream_]; + assert( + search_bounds_.starts[split_point_stream_] < + search_bounds_.ends[split_point_stream_]); + search_bounds_.ends[split_point_stream_] = + (search_bounds_.starts[split_point_stream_] + + search_bounds_.ends[split_point_stream_] + 1) / + 2; + + split_point_bounds = split_point_stream_bounds( + streams_, split_point_stream_, search_bounds_); + + search_bounds_.ends[split_point_stream_] = original_end; + } + + const uint64_t num_split_point_items = split_point_bounds.num_items(); + if (num_split_point_items == remaining_items_) { + search_bounds_ = split_point_bounds; + remaining_items_ = 0; + return SearchStep::Converged; + } else if (num_split_point_items < remaining_items_) { + // the split point has too few tuples + // we will include everything we found and advance + assert(search_bounds_.num_items() > 0); + remaining_items_ -= num_split_point_items; + search_bounds_.starts = split_point_bounds.ends; + return SearchStep::MadeProgress; + } else { + // this split point has too many tuples + // discard the items greater than the split point, and advance to a new + // split point + if (split_point_bounds == search_bounds_) { + return SearchStep::Stalled; + } else { + search_bounds_.ends = split_point_bounds.ends; + return SearchStep::MadeProgress; + } + } + } + + private: + uint64_t next_split_point_stream() const { + return (split_point_stream_ + 1) % streams_.size(); + } + + void advance_split_point_stream() { + for (unsigned i = 0; i < streams_.size(); i++) { + split_point_stream_ = next_split_point_stream(); + if (search_bounds_.starts[split_point_stream_] == + search_bounds_.ends[split_point_stream_]) { + continue; + } else { + return; + } + } + abort(); + } +}; + +template +std::shared_ptr identify_merge_unit( + Streams streams, uint64_t target_items) { + SearchMergeBoundary search(streams, target_items); + uint64_t stalled = 0; + + while (true) { + auto step = search.step(); + switch (step) { + case SearchStep::Stalled: + stalled++; + assert(stalled < streams.size()); + continue; + case SearchStep::MadeProgress: + stalled = 0; + continue; + case SearchStep::Converged: + return std::make_shared(search.current()); + } + } +} + +template +Status spawn_next_merge_unit( + ThreadPool* pool, + Streams streams, + uint64_t parallel_factor, + uint64_t total_items, + uint64_t target_unit_size, + uint64_t p, + std::shared_ptr previous, + T* output, + ParallelMergeFuture* future) { + const uint64_t output_end = std::min(total_items, (p + 1) * target_unit_size); + + auto accumulated_stream_bounds = identify_merge_unit(streams, output_end); + + future->merge_bounds_.push_back(output_end); + + if (previous) { + MergeUnit unit; + unit.starts = previous->ends; + unit.ends = accumulated_stream_bounds->ends; + + auto unit_future = pool->execute( + tournament_merge, + streams, + std::make_shared(std::move(unit)), + output); + future->merge_units_.push(std::move(unit_future)); + } else { + auto unit_future = pool->execute( + tournament_merge, streams, accumulated_stream_bounds, output); + future->merge_units_.push(std::move(unit_future)); + } + + if (p < parallel_factor - 1) { + pool->execute( + spawn_next_merge_unit, + pool, + streams, + parallel_factor, + total_items, + target_unit_size, + p + 1, + accumulated_stream_bounds, + output, + future); + } else { + future->merge_units_.drain(); + } + + return Status::Ok(); +} + +template +void spawn_merge_units( + ThreadPool& pool, + const ParallelMergeOptions& options, + Streams streams, + T* output, + ParallelMergeFuture& future) { + uint64_t total_items = 0; + for (const auto& stream : streams) { + total_items += stream.size(); + } + + const uint64_t parallel_factor = std::clamp( + total_items / options.min_merge_items, + static_cast(1), + options.parallel_factor); + + // NB: round up, if there is a shorter merge unit it will be the last one. + const uint64_t target_unit_size = + (total_items + (parallel_factor - 1)) / parallel_factor; + + pool.execute( + spawn_next_merge_unit, + &pool, + streams, + parallel_factor, + total_items, + target_unit_size, + static_cast(0), + std::shared_ptr(nullptr), + output, + &future); +} + +template +std::unique_ptr parallel_merge_impl( + tiledb::common::ThreadPool& pool, + const ParallelMergeOptions& options, + Streams streams, + uint64_t* output) { + std::unique_ptr future(new ParallelMergeFuture()); + spawn_merge_units(pool, options, streams, output, *future); + return future; +} + +std::unique_ptr parallel_merge( + tiledb::common::ThreadPool& pool, + const ParallelMergeOptions& options, + std::span> streams, + uint64_t* output) { + return std::move( + parallel_merge_impl(pool, options, streams, output)); +} + +} // namespace tiledb::algorithm diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h new file mode 100644 index 00000000000..0eaf7b1b894 --- /dev/null +++ b/tiledb/common/algorithm/parallel_merge.h @@ -0,0 +1,75 @@ +/** + * @file parallel_merge.h + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2018-2024 TileDB, 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. + * + * @section DESCRIPTION + * + * This file defines an implementation of a parallel merge algorithm for + * in-memory data. + * + * TODO: explain algorithm + */ + +#ifndef TILEDB_PARALLEL_MERGE_H +#define TILEDB_PARALLEL_MERGE_H + +#include "tiledb/common/thread_pool/producer_consumer_queue.h" +#include "tiledb/common/thread_pool/thread_pool.h" + +namespace tiledb::algorithm { + +struct ParallelMergeOptions { + uint64_t parallel_factor; + uint64_t min_merge_items; +}; + +struct ParallelMergeFuture { + std::vector merge_bounds_; + tiledb::common::ProducerConsumerQueue + merge_units_; + + /** + * Wait for more data to finish merging. + * + * @return the bound in the output stream up to which the merge has completed + */ + uint64_t await(); + + /** + * Wait for all data to finish merging. + */ + void block(); +}; + +std::unique_ptr parallel_merge( + tiledb::common::ThreadPool& pool, + const ParallelMergeOptions& options, + std::span> streams, + uint64_t* output); + +} // namespace tiledb::algorithm + +#endif diff --git a/tiledb/common/algorithm/test/CMakeLists.txt b/tiledb/common/algorithm/test/CMakeLists.txt new file mode 100644 index 00000000000..5523675e8a8 --- /dev/null +++ b/tiledb/common/algorithm/test/CMakeLists.txt @@ -0,0 +1,32 @@ +# +# tiledb/common/algorithm/test/CMakeLists.txt +# +# The MIT License +# +# Copyright (c) 2024 TileDB, 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. +# + +include(unit_test) + +commence(unit_test algorithm) + this_target_object_libraries(algorithm) + this_target_sources(main.cc unit_parallel_merge.cc) +conclude(unit_test) diff --git a/tiledb/common/algorithm/test/compile_algorithm_main.cc b/tiledb/common/algorithm/test/compile_algorithm_main.cc new file mode 100644 index 00000000000..34970908e08 --- /dev/null +++ b/tiledb/common/algorithm/test/compile_algorithm_main.cc @@ -0,0 +1,34 @@ +/** + * @file compile_untyped_datum_main.cc + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2021 TileDB, 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. + */ + +#include "../parallel_merge.h" + +int main() { + (void)sizeof(tiledb::algorithm::ParallelMergeOptions); + return 0; +} diff --git a/tiledb/common/algorithm/test/main.cc b/tiledb/common/algorithm/test/main.cc new file mode 100644 index 00000000000..bcfaef59927 --- /dev/null +++ b/tiledb/common/algorithm/test/main.cc @@ -0,0 +1,34 @@ +/** + * @file tiledb/common/test/main.cc + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2022 TileDB, 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. + * + * @section DESCRIPTION + * + * This file defines a test `main()` + */ + +#define CATCH_CONFIG_MAIN +#include diff --git a/tiledb/common/algorithm/test/unit_parallel_merge.cc b/tiledb/common/algorithm/test/unit_parallel_merge.cc new file mode 100644 index 00000000000..03b79ed3e35 --- /dev/null +++ b/tiledb/common/algorithm/test/unit_parallel_merge.cc @@ -0,0 +1,66 @@ +/** + * @file unit_parallel_merge.cc + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2018-2024 TileDB, 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. + * + * @section DESCRIPTION + */ + +#include "tiledb/common/algorithm/parallel_merge.h" + +#include + +using namespace tiledb::algorithm; +using namespace tiledb::common; + +TEST_CASE("parallel merge example", "[algorithm]") { + std::vector> streambufs = { + {123, 456, 789, 890, 901}, + {135, 357, 579, 791, 913}, + {24, 246, 468, 680, 802}, + {100, 200, 300, 400, 500}}; + + std::vector> streams = { + std::span(streambufs[0]), + std::span(streambufs[1]), + std::span(streambufs[2]), + std::span(streambufs[3]), + }; + + std::vector output(20); + + ParallelMergeOptions options = {.parallel_factor = 4, .min_merge_items = 4}; + + ThreadPool pool(options.parallel_factor); + + std::unique_ptr future = + parallel_merge(pool, options, streams, &output[0]); + + future->block(); + + CHECK(output == std::vector{24, 100, 123, 135, 200, 246, 300, + 357, 400, 456, 468, 500, 579, 680, + 789, 791, 802, 890, 901, 913}); +} diff --git a/tiledb/common/thread_pool/producer_consumer_queue.h b/tiledb/common/thread_pool/producer_consumer_queue.h index b4202ee555c..522a5b24ca4 100644 --- a/tiledb/common/thread_pool/producer_consumer_queue.h +++ b/tiledb/common/thread_pool/producer_consumer_queue.h @@ -148,7 +148,7 @@ class ProducerConsumerQueue { if (closed_ && queue_.empty()) { return {}; } - Item item = queue_.front(); + Item item = std::move(queue_.front()); if constexpr (std::is_same>::value) { queue_.pop(item); From ba90274ac77a7d72c71fabff850f73d36808c6ff Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 4 Dec 2024 15:04:12 -0500 Subject: [PATCH 002/228] Move template parallel merge impl into header and template Compare function --- tiledb/common/algorithm/parallel_merge.cc | 357 +---------------- tiledb/common/algorithm/parallel_merge.h | 375 +++++++++++++++++- .../algorithm/test/unit_parallel_merge.cc | 74 +++- 3 files changed, 435 insertions(+), 371 deletions(-) diff --git a/tiledb/common/algorithm/parallel_merge.cc b/tiledb/common/algorithm/parallel_merge.cc index e49129fd24b..faafdfff561 100644 --- a/tiledb/common/algorithm/parallel_merge.cc +++ b/tiledb/common/algorithm/parallel_merge.cc @@ -27,367 +27,26 @@ * * @section DESCRIPTION * - * This file defines an implementation of a parallel merge algorithm for - * in-memory data. + * This file contains non-template definition used in the parallel merge + * algorithm. */ #include "tiledb/common/algorithm/parallel_merge.h" -#include "tiledb/common/status.h" -#include "tiledb/common/thread_pool/thread_pool.h" - -#include using namespace tiledb::common; namespace tiledb::algorithm { -template -using Streams = std::span>; - void ParallelMergeFuture::block() { - while (merge_units_.pop().has_value()) - ; -} - -/** - * Represents one sequential unit of the parallel merge. - * - * Merges values in the ranges for each stream `s`, [starts[s], ends[s]]. - * This unit writes to the output in the range [sum(starts), sum(ends)]. - */ -struct MergeUnit { - std::vector starts; - std::vector ends; - - uint64_t num_items() const { - uint64_t total_items = 0; - for (size_t i = 0; i < starts.size(); i++) { - total_items += (ends[i] - starts[i]); - } - return total_items; - } - - uint64_t output_start() const { - uint64_t total_bound = 0; - for (size_t i = 0; i < ends.size(); i++) { - total_bound += starts[i]; - } - return total_bound; - } - - uint64_t output_end() const { - uint64_t total_bound = 0; - for (size_t i = 0; i < ends.size(); i++) { - total_bound += ends[i]; - } - return total_bound; - } - - bool operator==(const MergeUnit& other) const { - return (starts == other.starts) && (ends == other.ends); - } -}; - -template -struct span_greater { - bool operator()(const std::span l, const std::span r) const { - return std::greater()(l.front(), r.front()); - } -}; - -template -Status tournament_merge( - Streams streams, std::shared_ptr unit, T* output) { - std::vector> container; - container.reserve(streams.size()); - - // NB: we can definitely make a more optimized implementation - // which does a bunch of buffering for each battle in the tournament - // but this is straightforward - std::priority_queue, std::vector>, span_greater> - tournament({}, container); - - for (size_t i = 0; i < streams.size(); i++) { - if (unit->starts[i] != unit->ends[i]) { - tournament.push( - streams[i].subspan(unit->starts[i], unit->ends[i] - unit->starts[i])); - } - } - - size_t o = unit->output_start(); - - while (!tournament.empty()) { - auto stream = tournament.top(); - tournament.pop(); - - assert(!stream.empty()); - - output[o++] = stream.front(); - - if (stream.size() > 1) { - tournament.push(stream.subspan(1)); - } - } - - if (o == unit->output_end()) { - return Status::Ok(); - } else { - return Status_Error("Internal error in parallel merge"); - } -} - -template -MergeUnit split_point_stream_bounds( - Streams streams, uint64_t which, const MergeUnit& search_bounds) { - const T& split_point = streams[which][search_bounds.ends[which] - 1]; - - MergeUnit output; - output.starts = search_bounds.starts; - output.ends.reserve(streams.size()); - - for (uint64_t i = 0; i < streams.size(); i++) { - if (i == which) { - output.starts[i] = search_bounds.starts[i]; - output.ends.push_back(search_bounds.ends[i]); - } else { - std::span substream( - streams[i].begin() + search_bounds.starts[i], - streams[i].begin() + search_bounds.ends[i]); - - auto upper_bound = - std::upper_bound(substream.begin(), substream.end(), split_point); - output.ends.push_back( - output.starts[i] + std::distance(substream.begin(), upper_bound)); - } - } - - return output; -} - -enum class SearchStep { Stalled, MadeProgress, Converged }; - -template -struct SearchMergeBoundary { - Streams streams_; - uint64_t split_point_stream_; - uint64_t remaining_items_; - MergeUnit search_bounds_; - - SearchMergeBoundary(Streams streams, uint64_t target_items) - : streams_(streams) - , split_point_stream_(0) - , remaining_items_(target_items) { - search_bounds_.starts = std::vector(streams.size(), 0); - search_bounds_.ends.reserve(streams.size()); - for (const auto& stream : streams) { - search_bounds_.ends.push_back(stream.size()); - } - } - - MergeUnit current() const { - MergeUnit m; - m.starts = std::vector(search_bounds_.starts.size(), 0); - m.ends = search_bounds_.ends; - return m; - } - - SearchStep step() { - if (remaining_items_ == 0) { - return SearchStep::Converged; - } - - advance_split_point_stream(); - - MergeUnit split_point_bounds; - { - // temporarily shrink the split point stream bounds to indicate the split - // point - auto original_end = search_bounds_.ends[split_point_stream_]; - assert( - search_bounds_.starts[split_point_stream_] < - search_bounds_.ends[split_point_stream_]); - search_bounds_.ends[split_point_stream_] = - (search_bounds_.starts[split_point_stream_] + - search_bounds_.ends[split_point_stream_] + 1) / - 2; - - split_point_bounds = split_point_stream_bounds( - streams_, split_point_stream_, search_bounds_); - - search_bounds_.ends[split_point_stream_] = original_end; - } - - const uint64_t num_split_point_items = split_point_bounds.num_items(); - if (num_split_point_items == remaining_items_) { - search_bounds_ = split_point_bounds; - remaining_items_ = 0; - return SearchStep::Converged; - } else if (num_split_point_items < remaining_items_) { - // the split point has too few tuples - // we will include everything we found and advance - assert(search_bounds_.num_items() > 0); - remaining_items_ -= num_split_point_items; - search_bounds_.starts = split_point_bounds.ends; - return SearchStep::MadeProgress; - } else { - // this split point has too many tuples - // discard the items greater than the split point, and advance to a new - // split point - if (split_point_bounds == search_bounds_) { - return SearchStep::Stalled; - } else { - search_bounds_.ends = split_point_bounds.ends; - return SearchStep::MadeProgress; - } - } - } - - private: - uint64_t next_split_point_stream() const { - return (split_point_stream_ + 1) % streams_.size(); - } - - void advance_split_point_stream() { - for (unsigned i = 0; i < streams_.size(); i++) { - split_point_stream_ = next_split_point_stream(); - if (search_bounds_.starts[split_point_stream_] == - search_bounds_.ends[split_point_stream_]) { - continue; - } else { - return; - } - } - abort(); - } -}; - -template -std::shared_ptr identify_merge_unit( - Streams streams, uint64_t target_items) { - SearchMergeBoundary search(streams, target_items); - uint64_t stalled = 0; - while (true) { - auto step = search.step(); - switch (step) { - case SearchStep::Stalled: - stalled++; - assert(stalled < streams.size()); - continue; - case SearchStep::MadeProgress: - stalled = 0; - continue; - case SearchStep::Converged: - return std::make_shared(search.current()); + auto unit = merge_units_.pop(); + if (!unit.has_value()) { + break; + } else { + unit->wait(); } } } -template -Status spawn_next_merge_unit( - ThreadPool* pool, - Streams streams, - uint64_t parallel_factor, - uint64_t total_items, - uint64_t target_unit_size, - uint64_t p, - std::shared_ptr previous, - T* output, - ParallelMergeFuture* future) { - const uint64_t output_end = std::min(total_items, (p + 1) * target_unit_size); - - auto accumulated_stream_bounds = identify_merge_unit(streams, output_end); - - future->merge_bounds_.push_back(output_end); - - if (previous) { - MergeUnit unit; - unit.starts = previous->ends; - unit.ends = accumulated_stream_bounds->ends; - - auto unit_future = pool->execute( - tournament_merge, - streams, - std::make_shared(std::move(unit)), - output); - future->merge_units_.push(std::move(unit_future)); - } else { - auto unit_future = pool->execute( - tournament_merge, streams, accumulated_stream_bounds, output); - future->merge_units_.push(std::move(unit_future)); - } - - if (p < parallel_factor - 1) { - pool->execute( - spawn_next_merge_unit, - pool, - streams, - parallel_factor, - total_items, - target_unit_size, - p + 1, - accumulated_stream_bounds, - output, - future); - } else { - future->merge_units_.drain(); - } - - return Status::Ok(); -} - -template -void spawn_merge_units( - ThreadPool& pool, - const ParallelMergeOptions& options, - Streams streams, - T* output, - ParallelMergeFuture& future) { - uint64_t total_items = 0; - for (const auto& stream : streams) { - total_items += stream.size(); - } - - const uint64_t parallel_factor = std::clamp( - total_items / options.min_merge_items, - static_cast(1), - options.parallel_factor); - - // NB: round up, if there is a shorter merge unit it will be the last one. - const uint64_t target_unit_size = - (total_items + (parallel_factor - 1)) / parallel_factor; - - pool.execute( - spawn_next_merge_unit, - &pool, - streams, - parallel_factor, - total_items, - target_unit_size, - static_cast(0), - std::shared_ptr(nullptr), - output, - &future); -} - -template -std::unique_ptr parallel_merge_impl( - tiledb::common::ThreadPool& pool, - const ParallelMergeOptions& options, - Streams streams, - uint64_t* output) { - std::unique_ptr future(new ParallelMergeFuture()); - spawn_merge_units(pool, options, streams, output, *future); - return future; -} - -std::unique_ptr parallel_merge( - tiledb::common::ThreadPool& pool, - const ParallelMergeOptions& options, - std::span> streams, - uint64_t* output) { - return std::move( - parallel_merge_impl(pool, options, streams, output)); -} - } // namespace tiledb::algorithm + diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h index 0eaf7b1b894..a19b658c5a1 100644 --- a/tiledb/common/algorithm/parallel_merge.h +++ b/tiledb/common/algorithm/parallel_merge.h @@ -36,9 +36,13 @@ #ifndef TILEDB_PARALLEL_MERGE_H #define TILEDB_PARALLEL_MERGE_H +#include "tiledb/common/status.h" #include "tiledb/common/thread_pool/producer_consumer_queue.h" #include "tiledb/common/thread_pool/thread_pool.h" +#include +#include + namespace tiledb::algorithm { struct ParallelMergeOptions { @@ -64,11 +68,378 @@ struct ParallelMergeFuture { void block(); }; +template +std::unique_ptr parallel_merge( + tiledb::common::ThreadPool& pool, + const ParallelMergeOptions& options, + std::span> streams, + T* output); + +template +class ParallelMerge { + public: + typedef std::span> Streams; + + private: + /** + * Represents one sequential unit of the parallel merge. + * + * Merges values in the ranges for each stream `s`, [starts[s], ends[s]]. + * This unit writes to the output in the range [sum(starts), sum(ends)]. + */ + struct MergeUnit { + std::vector starts; + std::vector ends; + + uint64_t num_items() const { + uint64_t total_items = 0; + for (size_t i = 0; i < starts.size(); i++) { + total_items += (ends[i] - starts[i]); + } + return total_items; + } + + uint64_t output_start() const { + uint64_t total_bound = 0; + for (size_t i = 0; i < ends.size(); i++) { + total_bound += starts[i]; + } + return total_bound; + } + + uint64_t output_end() const { + uint64_t total_bound = 0; + for (size_t i = 0; i < ends.size(); i++) { + total_bound += ends[i]; + } + return total_bound; + } + + bool operator==(const MergeUnit& other) const { + return (starts == other.starts) && (ends == other.ends); + } + }; + + struct span_greater { + span_greater(Compare& cmp) + : cmp_(cmp) { + } + + bool operator()(const std::span l, const std::span r) const { + return !(cmp_(l.front(), r.front())); + } + + Compare cmp_; + }; + + static Status tournament_merge( + Streams streams, + Compare* cmp, + std::shared_ptr unit, + T* output) { + std::vector> container; + container.reserve(streams.size()); + + // NB: we can definitely make a more optimized implementation + // which does a bunch of buffering for each battle in the tournament + // but this is straightforward + std::priority_queue, std::vector>, span_greater> + tournament(span_greater(*cmp), container); + + for (size_t i = 0; i < streams.size(); i++) { + if (unit->starts[i] != unit->ends[i]) { + tournament.push(streams[i].subspan( + unit->starts[i], unit->ends[i] - unit->starts[i])); + } + } + + size_t o = unit->output_start(); + + while (!tournament.empty()) { + auto stream = tournament.top(); + tournament.pop(); + + assert(!stream.empty()); + + output[o++] = stream.front(); + + if (stream.size() > 1) { + tournament.push(stream.subspan(1)); + } + } + + if (o == unit->output_end()) { + return tiledb::common::Status::Ok(); + } else { + return tiledb::common::Status_Error("Internal error in parallel merge"); + } + } + + static MergeUnit split_point_stream_bounds( + Streams streams, + Compare& cmp, + uint64_t which, + const MergeUnit& search_bounds) { + const T& split_point = streams[which][search_bounds.ends[which] - 1]; + + MergeUnit output; + output.starts = search_bounds.starts; + output.ends.reserve(streams.size()); + + for (uint64_t i = 0; i < streams.size(); i++) { + if (i == which) { + output.starts[i] = search_bounds.starts[i]; + output.ends.push_back(search_bounds.ends[i]); + } else { + std::span substream( + streams[i].begin() + search_bounds.starts[i], + streams[i].begin() + search_bounds.ends[i]); + + auto upper_bound = + std::upper_bound( + substream.begin(), substream.end(), split_point, cmp); + output.ends.push_back( + output.starts[i] + std::distance(substream.begin(), upper_bound)); + } + } + + return output; + } + + enum class SearchStep { Stalled, MadeProgress, Converged }; + + struct SearchMergeBoundary { + Streams streams_; + Compare& cmp_; + uint64_t split_point_stream_; + uint64_t remaining_items_; + MergeUnit search_bounds_; + + SearchMergeBoundary(Streams streams, Compare& cmp, uint64_t target_items) + : streams_(streams) + , cmp_(cmp) + , split_point_stream_(0) + , remaining_items_(target_items) { + search_bounds_.starts = std::vector(streams.size(), 0); + search_bounds_.ends.reserve(streams.size()); + for (const auto& stream : streams) { + search_bounds_.ends.push_back(stream.size()); + } + } + + MergeUnit current() const { + MergeUnit m; + m.starts = std::vector(search_bounds_.starts.size(), 0); + m.ends = search_bounds_.ends; + return m; + } + + SearchStep step() { + if (remaining_items_ == 0) { + return SearchStep::Converged; + } + + advance_split_point_stream(); + + MergeUnit split_point_bounds; + { + // temporarily shrink the split point stream bounds to indicate the + // split point + auto original_end = search_bounds_.ends[split_point_stream_]; + assert( + search_bounds_.starts[split_point_stream_] < + search_bounds_.ends[split_point_stream_]); + search_bounds_.ends[split_point_stream_] = + (search_bounds_.starts[split_point_stream_] + + search_bounds_.ends[split_point_stream_] + 1) / + 2; + + split_point_bounds = split_point_stream_bounds( + streams_, cmp_, split_point_stream_, search_bounds_); + + search_bounds_.ends[split_point_stream_] = original_end; + } + + const uint64_t num_split_point_items = split_point_bounds.num_items(); + if (num_split_point_items == remaining_items_) { + search_bounds_ = split_point_bounds; + remaining_items_ = 0; + return SearchStep::Converged; + } else if (num_split_point_items < remaining_items_) { + // the split point has too few tuples + // we will include everything we found and advance + assert(search_bounds_.num_items() > 0); + remaining_items_ -= num_split_point_items; + search_bounds_.starts = split_point_bounds.ends; + return SearchStep::MadeProgress; + } else { + // this split point has too many tuples + // discard the items greater than the split point, and advance to a new + // split point + if (split_point_bounds == search_bounds_) { + return SearchStep::Stalled; + } else { + search_bounds_.ends = split_point_bounds.ends; + return SearchStep::MadeProgress; + } + } + } + + private: + uint64_t next_split_point_stream() const { + return (split_point_stream_ + 1) % streams_.size(); + } + + void advance_split_point_stream() { + for (unsigned i = 0; i < streams_.size(); i++) { + split_point_stream_ = next_split_point_stream(); + if (search_bounds_.starts[split_point_stream_] == + search_bounds_.ends[split_point_stream_]) { + continue; + } else { + return; + } + } + abort(); + } + }; + + static std::shared_ptr identify_merge_unit( + Streams streams, Compare* cmp, uint64_t target_items) { + SearchMergeBoundary search(streams, *cmp, target_items); + uint64_t stalled = 0; + + while (true) { + auto step = search.step(); + switch (step) { + case SearchStep::Stalled: + stalled++; + assert(stalled < streams.size()); + continue; + case SearchStep::MadeProgress: + stalled = 0; + continue; + case SearchStep::Converged: + return std::make_shared(search.current()); + } + } + } + + static Status spawn_next_merge_unit( + tiledb::common::ThreadPool* pool, + Streams streams, + Compare* cmp, + uint64_t parallel_factor, + uint64_t total_items, + uint64_t target_unit_size, + uint64_t p, + std::shared_ptr previous, + T* output, + ParallelMergeFuture* future) { + const uint64_t output_end = + std::min(total_items, (p + 1) * target_unit_size); + + auto accumulated_stream_bounds = + identify_merge_unit(streams, cmp, output_end); + + future->merge_bounds_.push_back(output_end); + + if (previous) { + MergeUnit unit; + unit.starts = previous->ends; + unit.ends = accumulated_stream_bounds->ends; + + auto unit_future = pool->execute( + tournament_merge, + streams, + cmp, + std::make_shared(std::move(unit)), + output); + future->merge_units_.push(std::move(unit_future)); + } else { + auto unit_future = pool->execute( + tournament_merge, streams, cmp, accumulated_stream_bounds, output); + future->merge_units_.push(std::move(unit_future)); + } + + if (p < parallel_factor - 1) { + pool->execute( + spawn_next_merge_unit, + pool, + streams, + cmp, + parallel_factor, + total_items, + target_unit_size, + p + 1, + accumulated_stream_bounds, + output, + future); + } else { + future->merge_units_.drain(); + } + + return tiledb::common::Status::Ok(); + } + + static void spawn_merge_units( + tiledb::common::ThreadPool& pool, + const ParallelMergeOptions& options, + Streams streams, + Compare& cmp, + T* output, + ParallelMergeFuture& future) { + uint64_t total_items = 0; + for (const auto& stream : streams) { + total_items += stream.size(); + } + + const uint64_t parallel_factor = std::clamp( + total_items / options.min_merge_items, + static_cast(1), + options.parallel_factor); + + // NB: round up, if there is a shorter merge unit it will be the last one. + const uint64_t target_unit_size = + (total_items + (parallel_factor - 1)) / parallel_factor; + + pool.execute( + spawn_next_merge_unit, + &pool, + streams, + &cmp, + parallel_factor, + total_items, + target_unit_size, + static_cast(0), + std::shared_ptr(nullptr), + output, + &future); + } + + public: + static std::unique_ptr start( + tiledb::common::ThreadPool& pool, + const ParallelMergeOptions& options, + Streams streams, + Compare& cmp, + uint64_t* output) { + std::unique_ptr future(new ParallelMergeFuture()); + ParallelMerge::spawn_merge_units( + pool, options, streams, cmp, output, *future); + return future; + } +}; + +template std::unique_ptr parallel_merge( tiledb::common::ThreadPool& pool, const ParallelMergeOptions& options, - std::span> streams, - uint64_t* output); + std::span> streams, + Compare& cmp, + T* output) { + return ParallelMerge::start(pool, options, streams, cmp, output); +} } // namespace tiledb::algorithm diff --git a/tiledb/common/algorithm/test/unit_parallel_merge.cc b/tiledb/common/algorithm/test/unit_parallel_merge.cc index 03b79ed3e35..f2104248abf 100644 --- a/tiledb/common/algorithm/test/unit_parallel_merge.cc +++ b/tiledb/common/algorithm/test/unit_parallel_merge.cc @@ -36,31 +36,65 @@ using namespace tiledb::algorithm; using namespace tiledb::common; TEST_CASE("parallel merge example", "[algorithm]") { - std::vector> streambufs = { - {123, 456, 789, 890, 901}, - {135, 357, 579, 791, 913}, - {24, 246, 468, 680, 802}, - {100, 200, 300, 400, 500}}; - - std::vector> streams = { - std::span(streambufs[0]), - std::span(streambufs[1]), - std::span(streambufs[2]), - std::span(streambufs[3]), - }; - std::vector output(20); ParallelMergeOptions options = {.parallel_factor = 4, .min_merge_items = 4}; - ThreadPool pool(options.parallel_factor); + ThreadPool pool(4); + + SECTION("less") { + auto cmp = std::less{}; + + std::vector> streambufs = { + {123, 456, 789, 890, 901}, + {135, 357, 579, 791, 913}, + {24, 246, 468, 680, 802}, + {100, 200, 300, 400, 500}}; + const std::vector expect = {24, 100, 123, 135, 200, 246, 300, + 357, 400, 456, 468, 500, 579, 680, + 789, 791, 802, 890, 901, 913}; + std::vector> streams = { + std::span(streambufs[0]), + std::span(streambufs[1]), + std::span(streambufs[2]), + std::span(streambufs[3]), + }; + + std::unique_ptr future = + parallel_merge( + pool, options, streams, cmp, &output[0]); + + future->block(); + + CHECK(output.size() == expect.size()); + CHECK(output == expect); + } + + SECTION("greater") { + auto cmp = std::greater{}; + + std::vector> streambufs = { + {901, 890, 789, 456, 123}, + {913, 791, 579, 357, 135}, + {802, 680, 468, 246, 24}, + {500, 400, 300, 200, 100}}; + const std::vector expect = {913, 901, 890, 802, 791, 789, 680, + 579, 500, 468, 456, 400, 357, 300, + 246, 200, 135, 123, 100, 24}; + std::vector> streams = { + std::span(streambufs[0]), + std::span(streambufs[1]), + std::span(streambufs[2]), + std::span(streambufs[3]), + }; - std::unique_ptr future = - parallel_merge(pool, options, streams, &output[0]); + std::unique_ptr future = + parallel_merge( + pool, options, streams, cmp, &output[0]); - future->block(); + future->block(); - CHECK(output == std::vector{24, 100, 123, 135, 200, 246, 300, - 357, 400, 456, 468, 500, 579, 680, - 789, 791, 802, 890, 901, 913}); + CHECK(output.size() == expect.size()); + CHECK(output == expect); + } } From b90353be982c2024a2cd1d4b99d9d7cf33d85814 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 4 Dec 2024 16:57:23 -0500 Subject: [PATCH 003/228] Domain::dimensions --- tiledb/sm/array_schema/domain.h | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/tiledb/sm/array_schema/domain.h b/tiledb/sm/array_schema/domain.h index 5f365c4021e..6f3ece12603 100644 --- a/tiledb/sm/array_schema/domain.h +++ b/tiledb/sm/array_schema/domain.h @@ -253,6 +253,13 @@ class Domain { return dimensions_[i]; } + /** + * @return a view over the dimensions + */ + inline std::span> dimensions() const { + return std::span(dimensions_.begin(), dimensions_.end()); + } + /** Returns the dimension given a name (nullptr upon error). */ const Dimension* dimension_ptr(const std::string& name) const; From 54a7de24d6814410b4fdb6a1381d12f006d017cf Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 5 Dec 2024 09:29:03 -0500 Subject: [PATCH 004/228] Remove trailing newline --- tiledb/common/algorithm/parallel_merge.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/tiledb/common/algorithm/parallel_merge.cc b/tiledb/common/algorithm/parallel_merge.cc index faafdfff561..6564237fcd8 100644 --- a/tiledb/common/algorithm/parallel_merge.cc +++ b/tiledb/common/algorithm/parallel_merge.cc @@ -49,4 +49,3 @@ void ParallelMergeFuture::block() { } } // namespace tiledb::algorithm - From ef488f85f4c1d74930e188f57e7535b958257d77 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 5 Dec 2024 09:29:25 -0500 Subject: [PATCH 005/228] TransientReadState::contains_tile --- .../sm/query/readers/sparse_index_reader_base.h | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/tiledb/sm/query/readers/sparse_index_reader_base.h b/tiledb/sm/query/readers/sparse_index_reader_base.h index 2a7553a70ed..d21334c8c03 100644 --- a/tiledb/sm/query/readers/sparse_index_reader_base.h +++ b/tiledb/sm/query/readers/sparse_index_reader_base.h @@ -431,6 +431,22 @@ class SparseIndexReaderBase : public ReaderBase { return tile_ranges_[f]; } + /** + * @param f Fragment index + * @param t Tile index + * @return true if the tile is included in the subarray, false otherwise + */ + bool contains_tile(unsigned f, uint64_t t) const { + // TODO: the comment claims this is reverse sorted, this can probably + // exploit that? + for (const auto& tile_range : tile_ranges_[f]) { + if (tile_range.first <= t && t <= tile_range.second) { + return true; + } + } + return false; + } + /** * Return if all tiles are loaded for a fragment. * From 900ebb27ad15bfdfa811c8ff5af9a34811ee8fc4 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 5 Dec 2024 09:30:10 -0500 Subject: [PATCH 006/228] void SparseGlobalOrderReader::compute_result_tile_order() first pass --- tiledb/sm/query/readers/result_tile.h | 5 + .../readers/sparse_global_order_reader.cc | 128 ++++++++++++++++++ .../readers/sparse_global_order_reader.h | 10 ++ tiledb/sm/tile/comparators.h | 125 +++++++++++++++++ 4 files changed, 268 insertions(+) create mode 100644 tiledb/sm/tile/comparators.h diff --git a/tiledb/sm/query/readers/result_tile.h b/tiledb/sm/query/readers/result_tile.h index 72cef169e50..ec39118abb7 100644 --- a/tiledb/sm/query/readers/result_tile.h +++ b/tiledb/sm/query/readers/result_tile.h @@ -70,6 +70,11 @@ class Subarray; */ bool result_tile_cmp(const ResultTile* a, const ResultTile* b); +struct ResultTileId { + unsigned fragment_idx_; + uint64_t tile_idx_; +}; + /** * Stores information about a logical dense or sparse result tile. Note that it * may store the physical tiles across more than one attributes for the same diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index e49c69133a6..5766f51f2bf 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -31,6 +31,7 @@ */ #include "tiledb/sm/query/readers/sparse_global_order_reader.h" +#include "tiledb/common/algorithm/parallel_merge.h" #include "tiledb/common/logger.h" #include "tiledb/common/memory_tracker.h" #include "tiledb/sm/array/array.h" @@ -46,6 +47,7 @@ #include "tiledb/sm/query/readers/result_tile.h" #include "tiledb/sm/stats/global_stats.h" #include "tiledb/sm/subarray/subarray.h" +#include "tiledb/sm/tile/comparators.h" using namespace tiledb; using namespace tiledb::common; @@ -333,6 +335,132 @@ bool SparseGlobalOrderReader::add_result_tile( return false; } +template +void SparseGlobalOrderReader::compute_result_tile_order() { + auto relevant_fragments = subarray_.relevant_fragments(); + + // FIXME: make sure `load_initial_data` is called first since that + // is the function which fills in the subarray stuff + + // first apply subarray (in parallel) + std::vector> fragment_result_tiles( + {}, fragment_metadata_.size()); + + if (!subarray_.is_set()) { + for (const auto& f : relevant_fragments) { + fragment_result_tiles[f].reserve(fragment_metadata_[f]->tile_num()); + } + } else { + /** + * Determines which tiles from a given fragment qualify for the subarray. + */ + auto populate_relevant_tiles = [&](uint64_t f) { + std::vector tile_is_relevant( + false, fragment_metadata_[f]->tile_num()); + + for (uint64_t t = 0; t < fragment_metadata_[f]->tile_num(); t++) { + if (tmp_read_state_.contains_tile(t, f)) { + tile_is_relevant[t] = true; + } + } + + const uint64_t num_relevant_tiles = + std::count(tile_is_relevant.begin(), tile_is_relevant.end(), true); + + fragment_result_tiles[f].reserve(num_relevant_tiles); + for (uint64_t t = 0; t < tile_is_relevant.size(); t++) { + if (tile_is_relevant[t]) { + fragment_result_tiles[f].push_back( + ResultTileId{.fragment_idx_ = f, .tile_idx_ = t}); + } + } + + return Status::Ok(); + }; + + auto populate_fragment_relevant_tiles = parallel_for( + &resources_.compute_tp(), + 0, + relevant_fragments, + populate_relevant_tiles); + throw_if_not_ok(populate_fragment_relevant_tiles); + } + + /* then do parallel merge */ + std::vector> fragment_result_tile_spans; + fragment_result_tile_spans.reserve(fragment_result_tiles.size()); + for (const auto& f : fragment_result_tiles) { + fragment_result_tile_spans = f; + } + + std::vector merged_result_tiles; + merged_result_tiles.reserve(std::accumulate( + fragment_result_tiles.begin(), fragment_result_tiles.end(), 0)); + + algorithm::ParallelMergeOptions merge_options = { + .parallel_factor = resources_.compute_tp().concurrency_level(), + .min_merge_size = + 128 // TODO: do some experiments to figure something out + }; + + auto do_global_order_merge = [&]() { + GlobalOrderMBRCmp cmp( + array_schema_.domain(), fragment_metadata_); + auto merge_stream = algorithm::parallel_merge( + resources_.compute_tp(), + merge_options, + std::span( + fragment_result_tile_spans.begin(), + fragment_result_tile_spans.end()), + &merged_result_tiles[0], + cmp); + + // TODO: we can begin the query as soon as the first merge unit is + // done. this will require extending the lifetime of `cmp`. + merge_stream.block(); + }; + + switch (array_schema_.cell_order()) { + case Layout::ROW_MAJOR: + switch (array_schema_.tile_order()) { + case Layout::ROW_MAJOR: { + do_global_order_merge + .template operator()(); + break; + } + case Layout::COL_MAJOR: { + do_global_order_merge + .template operator()(); + break; + } + default: + abort(); // TODO: rpobably an error? + } + break; + case Layout::COL_MAJOR: + switch (array_schema_.tile_order()) { + case Layout::ROW_MAJOR: { + do_global_order_merge + .template operator()(); + break; + } + case Layout::COL_MAJOR: { + do_global_order_merge + .template operator()(); + break; + } + default: + abort(); // TODO: rpobably an error? + } + break; + case Layout::HILBERT: + default: + abort(); // TODO + } + + result_tiles_ = merged_result_tiles; +} + template std::vector SparseGlobalOrderReader::create_result_tiles( diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index d5da6f20ce2..2043fd75292 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -136,6 +136,14 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, */ std::vector result_tiles_leftover_; + /** + * IDs of result tiles, arranged in global order. + * Note that tiles from different fragments may overlap + * (and may need to be de-duplicated if the schema requires unique + * coordinates). + */ + std::vector result_tiles_; + /** Memory used for coordinates tiles per fragment. */ std::vector memory_used_for_coords_; @@ -222,6 +230,8 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, const FragmentMetadata& frag_md, std::vector& result_tiles); + void compute_result_tile_order(); + /** * Create the result tiles. * diff --git a/tiledb/sm/tile/comparators.h b/tiledb/sm/tile/comparators.h new file mode 100644 index 00000000000..9f2abcf3268 --- /dev/null +++ b/tiledb/sm/tile/comparators.h @@ -0,0 +1,125 @@ +/** + * @file comparators.h + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2017-2024 TileDB, Inc. + * @copyright Copyright (c) 2016 MIT and Intel Corporation + * + * 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. + * + * @section DESCRIPTION + * + * Defines custom comparators to be used for arranging tiles according to + * their MBR (minimum bounding rectangle) found in fragment metadata. + */ + +#ifndef TILEDB_TILE_COMPARATORS_H +#define TILEDB_TILE_COMPARATORS_H + +#include "tiledb/sm/misc/comparators.h" +#include "tiledb/sm/query/readers/result_tile.h" + +namespace tiledb::sm { + +int cell_order_cmp_NDRange( + const Domain& domain, unsigned int d, const NDRange& a, const NDRange& b) { + const auto& dim = *domain.dimension_ptr(d); + if (dim.var_size()) { + UntypedDatumView v1(a[d].start_str().data(), a[d].start_str().size()); + UntypedDatumView v2(b[d].start_str().data(), a[d].start_str().size()); + return domain.cell_order_cmp(d, v1, v2); + } else { + UntypedDatumView v1(a[d].start_fixed(), a[d].start_size()); + UntypedDatumView v2(b[d].start_fixed(), a[d].start_size()); + return domain.cell_order_cmp(d, v1, v2); + } +} + +template +class GlobalOrderMBRCmp { + explicit GlobalOrderMBRCmp( + const Domain& domain, + const std::vector>& fragment_metadata) + : domain_(domain) + , fragment_metadata_(fragment_metadata) { + static_assert( + TILE_ORDER == Layout::ROW_MAJOR || TILE_ORDER == Layout::COL_MAJOR); + static_assert( + CELL_ORDER == Layout::ROW_MAJOR || CELL_ORDER == Layout::COL_MAJOR); + } + + bool operator()(const NDRange& left_mbr, const NDRange& right_mbr) const { + for (unsigned di = 0; di < domain_.dim_num(); ++di) { + const unsigned d = + (TILE_ORDER == Layout::ROW_MAJOR ? d : (domain_.dim_num() - d - 1)); + + // Not applicable to var-sized dimensions + if (domain_.dimension_ptr(d)->var_size()) + continue; + + auto res = + domain_.tile_order_cmp(d, left_mbr[d].data(), right_mbr[d].data()); + if (res < 0) { + return true; + } else if (res > 0) { + return false; + } + // else same tile on dimension d --> continue + } + + // then cell order + for (unsigned di = 0; di < domain_.dim_num(); ++di) { + const unsigned d = + (CELL_ORDER == Layout::ROW_MAJOR ? d : (domain_.dim_num() - d - 1)); + auto res = cell_order_cmp_NDRange(domain_, d, left_mbr, right_mbr); + + if (res < 0) { + return true; + } else if (res > 0) { + return false; + } + // else same tile on dimension d --> continue + } + + // NB: some other comparators care about timestamps here, we will not bother + // (for now?) + return 0; + } + + bool operator()(const ResultTileId& left, const ResultTileId& right) const { + const auto& left_mbr = + fragment_metadata_[left.fragment_idx_]->mbr(left.tile_idx_); + const auto& right_mbr = + fragment_metadata_[right.fragment_idx_]->mbr(right.tile_idx_); + + return (*this)(left_mbr, right_mbr); + } + + private: + const Domain& domain_; + + const std::vector>& fragment_metadata_; +}; + +} // namespace tiledb::sm + +#endif From 334eb0ddcc34cd8914c4c3d7bfaf95a1baa643e2 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 5 Dec 2024 11:27:38 -0500 Subject: [PATCH 007/228] Fix uint64_t in ParallelMerge --- tiledb/common/algorithm/parallel_merge.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h index a19b658c5a1..330da110b1e 100644 --- a/tiledb/common/algorithm/parallel_merge.h +++ b/tiledb/common/algorithm/parallel_merge.h @@ -423,7 +423,7 @@ class ParallelMerge { const ParallelMergeOptions& options, Streams streams, Compare& cmp, - uint64_t* output) { + T* output) { std::unique_ptr future(new ParallelMergeFuture()); ParallelMerge::spawn_merge_units( pool, options, streams, cmp, output, *future); From 399023b0b59b80a36e49a1edaf40f19b7b6de7c6 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 5 Dec 2024 11:28:31 -0500 Subject: [PATCH 008/228] Fix errors in compute_result_tile_order --- .../readers/sparse_global_order_reader.cc | 38 ++++++++++++------- tiledb/sm/tile/comparators.h | 1 + 2 files changed, 25 insertions(+), 14 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 5766f51f2bf..ece82405937 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -344,17 +344,21 @@ void SparseGlobalOrderReader::compute_result_tile_order() { // first apply subarray (in parallel) std::vector> fragment_result_tiles( - {}, fragment_metadata_.size()); + fragment_metadata_.size()); if (!subarray_.is_set()) { for (const auto& f : relevant_fragments) { fragment_result_tiles[f].reserve(fragment_metadata_[f]->tile_num()); } } else { + const uint64_t num_relevant_fragments = relevant_fragments.size(); + /** * Determines which tiles from a given fragment qualify for the subarray. */ - auto populate_relevant_tiles = [&](uint64_t f) { + auto populate_relevant_tiles = [&](unsigned rf) { + const unsigned f = relevant_fragments[rf]; + std::vector tile_is_relevant( false, fragment_metadata_[f]->tile_num()); @@ -381,43 +385,49 @@ void SparseGlobalOrderReader::compute_result_tile_order() { auto populate_fragment_relevant_tiles = parallel_for( &resources_.compute_tp(), 0, - relevant_fragments, + num_relevant_fragments, populate_relevant_tiles); throw_if_not_ok(populate_fragment_relevant_tiles); } + size_t num_result_tiles = 0; + for (const auto& fragment : fragment_result_tiles) { + num_result_tiles += fragment.size(); + } + /* then do parallel merge */ std::vector> fragment_result_tile_spans; fragment_result_tile_spans.reserve(fragment_result_tiles.size()); - for (const auto& f : fragment_result_tiles) { - fragment_result_tile_spans = f; + for (auto& f : fragment_result_tiles) { + fragment_result_tile_spans.push_back(std::span(f)); } - std::vector merged_result_tiles; - merged_result_tiles.reserve(std::accumulate( - fragment_result_tiles.begin(), fragment_result_tiles.end(), 0)); + std::vector merged_result_tiles( + num_result_tiles, ResultTileId{.fragment_idx_ = 0, .tile_idx_ = 0}); algorithm::ParallelMergeOptions merge_options = { .parallel_factor = resources_.compute_tp().concurrency_level(), - .min_merge_size = + .min_merge_items = 128 // TODO: do some experiments to figure something out }; auto do_global_order_merge = [&]() { GlobalOrderMBRCmp cmp( array_schema_.domain(), fragment_metadata_); - auto merge_stream = algorithm::parallel_merge( + auto merge_stream = algorithm::parallel_merge( resources_.compute_tp(), merge_options, + fragment_result_tile_spans, + /* std::span( fragment_result_tile_spans.begin(), - fragment_result_tile_spans.end()), - &merged_result_tiles[0], - cmp); + fragment_result_tile_spans.end()),*/ + cmp, + &merged_result_tiles[0]); // TODO: we can begin the query as soon as the first merge unit is // done. this will require extending the lifetime of `cmp`. - merge_stream.block(); + merge_stream->block(); }; switch (array_schema_.cell_order()) { diff --git a/tiledb/sm/tile/comparators.h b/tiledb/sm/tile/comparators.h index 9f2abcf3268..a0d156e9823 100644 --- a/tiledb/sm/tile/comparators.h +++ b/tiledb/sm/tile/comparators.h @@ -56,6 +56,7 @@ int cell_order_cmp_NDRange( template class GlobalOrderMBRCmp { + public: explicit GlobalOrderMBRCmp( const Domain& domain, const std::vector>& fragment_metadata) From 0593e30d8698ac39c0e2e57a162119d087bb598b Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 5 Dec 2024 13:58:05 -0500 Subject: [PATCH 009/228] Fix indexing error in GlobalOrderMBRCmp --- tiledb/sm/tile/comparators.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tiledb/sm/tile/comparators.h b/tiledb/sm/tile/comparators.h index a0d156e9823..9607fc344cf 100644 --- a/tiledb/sm/tile/comparators.h +++ b/tiledb/sm/tile/comparators.h @@ -71,7 +71,7 @@ class GlobalOrderMBRCmp { bool operator()(const NDRange& left_mbr, const NDRange& right_mbr) const { for (unsigned di = 0; di < domain_.dim_num(); ++di) { const unsigned d = - (TILE_ORDER == Layout::ROW_MAJOR ? d : (domain_.dim_num() - d - 1)); + (TILE_ORDER == Layout::ROW_MAJOR ? di : (domain_.dim_num() - di - 1)); // Not applicable to var-sized dimensions if (domain_.dimension_ptr(d)->var_size()) @@ -90,7 +90,7 @@ class GlobalOrderMBRCmp { // then cell order for (unsigned di = 0; di < domain_.dim_num(); ++di) { const unsigned d = - (CELL_ORDER == Layout::ROW_MAJOR ? d : (domain_.dim_num() - d - 1)); + (CELL_ORDER == Layout::ROW_MAJOR ? di : (domain_.dim_num() - di - 1)); auto res = cell_order_cmp_NDRange(domain_, d, left_mbr, right_mbr); if (res < 0) { From 007e43d41823011fb937ac3241603e1cb8c3ad48 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 5 Dec 2024 13:58:55 -0500 Subject: [PATCH 010/228] Change test section names so that -c option can be used --- test/src/unit-sparse-global-order-reader.cc | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index b219ff26b82..2168715f5da 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -907,27 +907,27 @@ TEST_CASE_METHOD( bool use_subarray = false; int tile_idx = 0; int qc_idx = GENERATE(1, 2); - SECTION("- No subarray") { + SECTION("No subarray") { use_subarray = false; - SECTION("- First tile") { + SECTION("First tile") { tile_idx = 0; } - SECTION("- Second tile") { + SECTION("Second tile") { tile_idx = 1; } - SECTION("- Last tile") { + SECTION("Last tile") { tile_idx = 2; } } - SECTION("- Subarray") { + SECTION("Subarray") { use_subarray = true; - SECTION("- First tile") { + SECTION("First tile") { tile_idx = 0; } - SECTION("- Second tile") { + SECTION("Second tile") { tile_idx = 1; } - SECTION("- Last tile") { + SECTION("Last tile") { tile_idx = 2; } } From 169b20e238ab960692667784533f69b026e234c2 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 5 Dec 2024 14:12:48 -0500 Subject: [PATCH 011/228] Passing 'qc removes full tile' unit test with compute_result_tile_order --- .../readers/sparse_global_order_reader.cc | 210 ++++++++---------- .../readers/sparse_global_order_reader.h | 3 +- .../query/readers/sparse_index_reader_base.h | 3 +- 3 files changed, 98 insertions(+), 118 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index ece82405937..06635e5aeb3 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -138,6 +138,14 @@ Status SparseGlobalOrderReader::dowork() { // Load initial data, if not loaded already. throw_if_not_ok(load_initial_data()); + + // Determine result tile order + // (this happens after load_initial_data which identifies which tiles pass + // subarray) + if (result_tile_ids_.empty()) { + compute_result_tile_order(); + } + purge_deletes_consolidation_ = !deletes_consolidation_no_purge_ && consolidation_with_timestamps_ && !delete_and_update_conditions_.empty(); @@ -145,6 +153,7 @@ Status SparseGlobalOrderReader::dowork() { !array_schema_.allows_dups() && purge_deletes_consolidation_; // Load tile offsets, if required. + // FIXME: only needs to load offsets in result_tile_ids_ load_all_tile_offsets(); // Field names to process. @@ -335,24 +344,39 @@ bool SparseGlobalOrderReader::add_result_tile( return false; } +/** + * @precondition the `TempReadState` is up to date with which tiles pass the + * subarray (e.g. by calling `load_initial_data`) + */ template void SparseGlobalOrderReader::compute_result_tile_order() { - auto relevant_fragments = subarray_.relevant_fragments(); - - // FIXME: make sure `load_initial_data` is called first since that - // is the function which fills in the subarray stuff + const auto& relevant_fragments = subarray_.relevant_fragments(); + const uint64_t num_relevant_fragments = relevant_fragments.size(); // first apply subarray (in parallel) std::vector> fragment_result_tiles( fragment_metadata_.size()); + // TODO: ideally this could be async or on demand for each tile + // so that we could be closer to a proper LIMIT + subarray_.load_relevant_fragment_rtrees(&resources_.compute_tp()); + if (!subarray_.is_set()) { for (const auto& f : relevant_fragments) { fragment_result_tiles[f].reserve(fragment_metadata_[f]->tile_num()); } + auto populate_fragment_relevant_tiles = parallel_for( + &resources_.compute_tp(), 0, num_relevant_fragments, [&](unsigned rf) { + const unsigned f = relevant_fragments[rf]; + fragment_result_tiles[f].reserve(fragment_metadata_[f]->tile_num()); + for (uint64_t t = 0; t < fragment_metadata_[f]->tile_num(); t++) { + fragment_result_tiles[f].push_back( + ResultTileId{.fragment_idx_ = f, .tile_idx_ = t}); + } + return Status::Ok(); + }); + throw_if_not_ok(populate_fragment_relevant_tiles); } else { - const uint64_t num_relevant_fragments = relevant_fragments.size(); - /** * Determines which tiles from a given fragment qualify for the subarray. */ @@ -360,10 +384,10 @@ void SparseGlobalOrderReader::compute_result_tile_order() { const unsigned f = relevant_fragments[rf]; std::vector tile_is_relevant( - false, fragment_metadata_[f]->tile_num()); + fragment_metadata_[f]->tile_num(), false); for (uint64_t t = 0; t < fragment_metadata_[f]->tile_num(); t++) { - if (tmp_read_state_.contains_tile(t, f)) { + if (tmp_read_state_.contains_tile(f, t)) { tile_is_relevant[t] = true; } } @@ -388,6 +412,8 @@ void SparseGlobalOrderReader::compute_result_tile_order() { num_relevant_fragments, populate_relevant_tiles); throw_if_not_ok(populate_fragment_relevant_tiles); + + tmp_read_state_.clear_tile_ranges(); } size_t num_result_tiles = 0; @@ -468,7 +494,8 @@ void SparseGlobalOrderReader::compute_result_tile_order() { abort(); // TODO } - result_tiles_ = merged_result_tiles; + result_tile_ids_ = merged_result_tiles; + result_tile_cursor_ = 0; } template @@ -478,129 +505,80 @@ SparseGlobalOrderReader::create_result_tiles( auto timer_se = stats_->start_timer("create_result_tiles"); // For easy reference. - auto fragment_num = fragment_metadata_.size(); - auto dim_num = array_schema_.dim_num(); - - // Get the number of fragments to process and compute per fragment memory. - uint64_t num_fragments_to_process = - tmp_read_state_.num_fragments_to_process(); + const auto num_fragments = fragment_metadata_.size(); + const auto num_dims = array_schema_.dim_num(); - // Save which result tile list is empty. + // Distinguish between leftover result tiles from the previous `submit` + // and result tiles which are being added now std::vector rt_list_num_tiles(result_tiles.size()); for (uint64_t i = 0; i < result_tiles.size(); i++) { rt_list_num_tiles[i] = result_tiles[i].size(); } - if (num_fragments_to_process > 0) { - per_fragment_memory_ = - memory_budget_.coordinates_budget() / num_fragments_to_process; - - // Create result tiles. - if (subarray_.is_set()) { - // Load as many tiles as the memory budget allows. - throw_if_not_ok(parallel_for( - &resources_.compute_tp(), 0, fragment_num, [&](uint64_t f) { - uint64_t t = 0; - auto& tile_ranges = tmp_read_state_.tile_ranges(f); - while (!tile_ranges.empty()) { - auto& range = tile_ranges.back(); - for (t = range.first; t <= range.second; t++) { - auto budget_exceeded = add_result_tile( - dim_num, - per_fragment_memory_, - f, - t, - *fragment_metadata_[f], - result_tiles); - - if (budget_exceeded) { - logger_->debug( - "Budget exceeded adding result tiles, fragment {0}, tile " - "{1}", - f, - t); - - if (result_tiles[f].empty()) { - auto tiles_size = get_coord_tiles_size(dim_num, f, t); - throw SparseGlobalOrderReaderException( - "Cannot load a single tile for fragment, increase " - "memory " - "budget, tile size : " + - std::to_string(tiles_size) + ", per fragment memory " + - std::to_string(per_fragment_memory_) + - ", total budget " + - std::to_string(memory_budget_.total_budget()) + - ", processing fragment " + std::to_string(f) + - " out of " + std::to_string(num_fragments_to_process) + - " total fragments"); - } - return Status::Ok(); - } - - range.first++; - } - - tmp_read_state_.remove_tile_range(f); - } + if (result_tile_cursor_ < result_tile_ids_.size()) { + // FIXME: + // when there is a real budget constraint we will probably + // have to peek at the result tile MBRs to make sure that + // what gets put in `result_tiles` are fully disjoint with + // tiles from other fragments that *don't* get put in `result_tiles`. + // this will be necessary for the merge later on to prevent + // a subsequent `submit` from getting out of order data. + size_t merge_ok_bound = result_tile_cursor_; + + for (size_t rt = result_tile_cursor_; rt < result_tile_ids_.size(); rt++) { + const auto f = result_tile_ids_[rt].fragment_idx_; + const auto t = result_tile_ids_[rt].tile_idx_; + + auto budget_exceeded = add_result_tile( + num_dims, + memory_budget_.coordinates_budget(), + f, + t, + *fragment_metadata_[f], + result_tiles); + + if (budget_exceeded) { + logger_->debug( + "Budget exceeded adding result tiles, fragment {0}, tile " + "{1}", + f, + t); + + if (merge_ok_bound == result_tile_cursor_) { + // this means we cannot safely produce any results + throw SparseGlobalOrderReaderException("TODO"); + } + } - tmp_read_state_.set_all_tiles_loaded(f); + // FIXME: see comment above + // really what we need to do is flip the iteration to identify the merge + // ok units, and then see if we can fit *all* of them within the memory + // budget + merge_ok_bound++; + } - return Status::Ok(); - })); - } else { - // Load as many tiles as the memory budget allows. - throw_if_not_ok(parallel_for( - &resources_.compute_tp(), 0, fragment_num, [&](uint64_t f) { - uint64_t t = 0; - auto tile_num = fragment_metadata_[f]->tile_num(); - - // Figure out the start index. - auto start = read_state_.frag_idx()[f].tile_idx_; - if (!result_tiles[f].empty()) { - start = std::max(start, result_tiles[f].back().tile_idx() + 1); - } + if (merge_ok_bound == result_tile_cursor_) { + // cannot progress + throw SparseGlobalOrderReaderException("TODO"); + } - for (t = start; t < tile_num; t++) { - auto budget_exceeded = add_result_tile( - dim_num, - per_fragment_memory_, - f, - t, - *fragment_metadata_[f], - result_tiles); - - if (budget_exceeded) { - logger_->debug( - "Budget exceeded adding result tiles, fragment {0}, tile " - "{1}", - f, - t); - - if (result_tiles[f].empty()) { - auto tiles_size = get_coord_tiles_size(dim_num, f, t); - return logger_->status(Status_SparseGlobalOrderReaderError( - "Cannot load a single tile for fragment, increase memory " - "budget, tile size : " + - std::to_string(tiles_size) + ", per fragment memory " + - std::to_string(per_fragment_memory_) + ", total budget " + - std::to_string(memory_budget_.total_budget()) + - ", num fragments to process " + - std::to_string(num_fragments_to_process))); - } - return Status::Ok(); - } - } + // update position for next iteration + result_tile_cursor_ = merge_ok_bound; - tmp_read_state_.set_all_tiles_loaded(f); + if (result_tile_cursor_ == result_tile_ids_.size()) { + // TODO: original version sets a flag in tmp_read_state_ on a per-fragment + // basis, does that have any effect other than computing this? + read_state_.set_done_adding_result_tiles(true); - return Status::Ok(); - })); + for (unsigned f = 0; f < num_fragments; f++) { + tmp_read_state_.set_all_tiles_loaded(f); + } } } bool done_adding_result_tiles = tmp_read_state_.done_adding_result_tiles(); uint64_t num_rt = 0; - for (unsigned int f = 0; f < fragment_num; f++) { + for (unsigned int f = 0; f < num_fragments; f++) { num_rt += result_tiles[f].size(); } diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index 2043fd75292..58429c70804 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -142,7 +142,8 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, * (and may need to be de-duplicated if the schema requires unique * coordinates). */ - std::vector result_tiles_; + std::vector result_tile_ids_; + size_t result_tile_cursor_; /** Memory used for coordinates tiles per fragment. */ std::vector memory_used_for_coords_; diff --git a/tiledb/sm/query/readers/sparse_index_reader_base.h b/tiledb/sm/query/readers/sparse_index_reader_base.h index d21334c8c03..9b5c540fc8b 100644 --- a/tiledb/sm/query/readers/sparse_index_reader_base.h +++ b/tiledb/sm/query/readers/sparse_index_reader_base.h @@ -438,7 +438,8 @@ class SparseIndexReaderBase : public ReaderBase { */ bool contains_tile(unsigned f, uint64_t t) const { // TODO: the comment claims this is reverse sorted, this can probably - // exploit that? + // exploit that? Looks like the previous implementation did do so, + // iterating in reverse order and then popping off the back for (const auto& tile_range : tile_ranges_[f]) { if (tile_range.first <= t && t <= tile_range.second) { return true; From a8cd4b021a075f08f476a1566cbf1c228eb88316 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 5 Dec 2024 14:24:58 -0500 Subject: [PATCH 012/228] Remove per-fragment memory fields --- tiledb/sm/query/readers/sparse_global_order_reader.cc | 9 +-------- tiledb/sm/query/readers/sparse_global_order_reader.h | 6 ------ 2 files changed, 1 insertion(+), 14 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 06635e5aeb3..adc4e40b263 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -79,7 +79,6 @@ SparseGlobalOrderReader::SparseGlobalOrderReader( params, true) , result_tiles_leftover_(array_->fragment_metadata().size()) - , memory_used_for_coords_(array_->fragment_metadata().size()) , consolidation_with_timestamps_(consolidation_with_timestamps) , last_cells_(array_->fragment_metadata().size()) , tile_offsets_loaded_(false) { @@ -322,16 +321,13 @@ bool SparseGlobalOrderReader::add_result_tile( auto tiles_size = get_coord_tiles_size(dim_num, f, t); // Don't load more tiles than the memory budget. - if (memory_used_for_coords_[f] + tiles_size > memory_budget_coords_tiles) { + if (memory_used_for_coords_total_ + tiles_size > memory_budget_coords_tiles) { return true; } // Adjust total memory used. memory_used_for_coords_total_ += tiles_size; - // Adjust per fragment memory used. - memory_used_for_coords_[f] += tiles_size; - // Add the tile. result_tiles[f].emplace_back( f, @@ -2297,9 +2293,6 @@ void SparseGlobalOrderReader::remove_result_tile( auto tiles_size = get_coord_tiles_size(array_schema_.dim_num(), frag_idx, tile_idx); - // Adjust per fragment memory usage. - memory_used_for_coords_[frag_idx] -= tiles_size; - // Adjust total memory usage. memory_used_for_coords_total_ -= tiles_size; diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index 58429c70804..ca88f4466c2 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -145,12 +145,6 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, std::vector result_tile_ids_; size_t result_tile_cursor_; - /** Memory used for coordinates tiles per fragment. */ - std::vector memory_used_for_coords_; - - /** Memory budget per fragment. */ - double per_fragment_memory_; - /** Enables consolidation with timestamps or not. */ bool consolidation_with_timestamps_; From a9d78d0830135d6a9780dc920a5078fecc2331a8 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 6 Dec 2024 10:18:28 -0500 Subject: [PATCH 013/228] TEST_CASE parallel merge rapidcheck verify_split_point_stream_bounds --- test/CMakeLists.txt | 9 + test/support/tdb_rapidcheck.h | 47 +++++ tiledb/common/algorithm/parallel_merge.h | 83 ++++----- tiledb/common/algorithm/test/CMakeLists.txt | 1 + .../algorithm/test/unit_parallel_merge.cc | 161 +++++++++++++++++- vcpkg.json | 3 +- 6 files changed, 264 insertions(+), 40 deletions(-) create mode 100644 test/support/tdb_rapidcheck.h diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index be78652132c..87117729340 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -347,6 +347,15 @@ if (LIBFAKETIME) set_property(TEST tiledb_timing_unit PROPERTY ENVIRONMENT_MODIFICATION "FAKETIME=set:2020-12-24 20:30:00;LD_PRELOAD=path_list_append:${LIBFAKETIME}") endif() +find_library( + LIBRAPIDCHECK + NAMES rapidcheck +) + +#if (LIBRAPIDCHECK) +# add_subdirectory(${LIBRAPIDCHECK}) +#endif() + add_test( NAME "tiledb_unit" COMMAND tiledb_unit --durations=yes diff --git a/test/support/tdb_rapidcheck.h b/test/support/tdb_rapidcheck.h new file mode 100644 index 00000000000..39a30682e78 --- /dev/null +++ b/test/support/tdb_rapidcheck.h @@ -0,0 +1,47 @@ +/** + * @file tdb_rapidcheck.h + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2022-2023 TileDB, 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. + * + * @section DESCRIPTION + * + * This file wraps and for convenience + * (and compatibility due to a snag with ). + */ + +#ifndef TILEDB_MISC_TDB_RAPIDCHECK_H +#define TILEDB_MISC_TDB_RAPIDCHECK_H + +/* + * `catch` must be included first to define + * `CATCH_TEST_MACROS_HPP_INCLUDED` + * which is the bridge between v2 and v3 compatibility for + */ +#include + +#include +#include + +#endif // TILEDB_MISC_TDB_RAPIDCHECK_H diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h index 330da110b1e..fed6bb354d0 100644 --- a/tiledb/common/algorithm/parallel_merge.h +++ b/tiledb/common/algorithm/parallel_merge.h @@ -68,58 +68,62 @@ struct ParallelMergeFuture { void block(); }; -template +template > std::unique_ptr parallel_merge( tiledb::common::ThreadPool& pool, const ParallelMergeOptions& options, std::span> streams, T* output); -template -class ParallelMerge { - public: - typedef std::span> Streams; +/** + * Represents one sequential unit of the parallel merge. + * + * Merges values in the ranges for each stream `s`, [starts[s], ends[s]]. + * This unit writes to the output in the range [sum(starts), sum(ends)]. + */ +struct MergeUnit { + std::vector starts; + std::vector ends; - private: - /** - * Represents one sequential unit of the parallel merge. - * - * Merges values in the ranges for each stream `s`, [starts[s], ends[s]]. - * This unit writes to the output in the range [sum(starts), sum(ends)]. - */ - struct MergeUnit { - std::vector starts; - std::vector ends; - - uint64_t num_items() const { - uint64_t total_items = 0; - for (size_t i = 0; i < starts.size(); i++) { - total_items += (ends[i] - starts[i]); - } - return total_items; + uint64_t num_items() const { + uint64_t total_items = 0; + for (size_t i = 0; i < starts.size(); i++) { + total_items += (ends[i] - starts[i]); } + return total_items; + } - uint64_t output_start() const { - uint64_t total_bound = 0; - for (size_t i = 0; i < ends.size(); i++) { - total_bound += starts[i]; - } - return total_bound; + uint64_t output_start() const { + uint64_t total_bound = 0; + for (size_t i = 0; i < ends.size(); i++) { + total_bound += starts[i]; } + return total_bound; + } - uint64_t output_end() const { - uint64_t total_bound = 0; - for (size_t i = 0; i < ends.size(); i++) { - total_bound += ends[i]; - } - return total_bound; + uint64_t output_end() const { + uint64_t total_bound = 0; + for (size_t i = 0; i < ends.size(); i++) { + total_bound += ends[i]; } + return total_bound; + } - bool operator==(const MergeUnit& other) const { - return (starts == other.starts) && (ends == other.ends); - } - }; + bool operator==(const MergeUnit& other) const { + return (starts == other.starts) && (ends == other.ends); + } +}; +// forward declarations of friend classes for testing +template +struct VerifySplitPointStream; + +template > +class ParallelMerge { + public: + typedef std::span> Streams; + + private: struct span_greater { span_greater(Compare& cmp) : cmp_(cmp) { @@ -417,6 +421,9 @@ class ParallelMerge { &future); } + // friend declarations for testing + friend struct VerifySplitPointStream; + public: static std::unique_ptr start( tiledb::common::ThreadPool& pool, diff --git a/tiledb/common/algorithm/test/CMakeLists.txt b/tiledb/common/algorithm/test/CMakeLists.txt index 5523675e8a8..c3e5e291479 100644 --- a/tiledb/common/algorithm/test/CMakeLists.txt +++ b/tiledb/common/algorithm/test/CMakeLists.txt @@ -29,4 +29,5 @@ include(unit_test) commence(unit_test algorithm) this_target_object_libraries(algorithm) this_target_sources(main.cc unit_parallel_merge.cc) + this_target_link_libraries(${LIBRAPIDCHECK}) conclude(unit_test) diff --git a/tiledb/common/algorithm/test/unit_parallel_merge.cc b/tiledb/common/algorithm/test/unit_parallel_merge.cc index f2104248abf..2b6eb9a0ab5 100644 --- a/tiledb/common/algorithm/test/unit_parallel_merge.cc +++ b/tiledb/common/algorithm/test/unit_parallel_merge.cc @@ -31,11 +31,170 @@ #include "tiledb/common/algorithm/parallel_merge.h" #include +#include using namespace tiledb::algorithm; using namespace tiledb::common; -TEST_CASE("parallel merge example", "[algorithm]") { +namespace tiledb::algorithm { + +template +using Streams = std::vector>; + +/** + * An instance of an input to the `split_point_stream_bounds` + * function. + * + * The `verify` method checks correctness of `split_point_stream_bounds` + * with respect to the input. + */ +template +struct VerifySplitPointStream { + Streams streams; + uint64_t which; + MergeUnit search_bounds; + + void verify() { + RC_ASSERT(streams.size() == search_bounds.starts.size()); + RC_ASSERT(search_bounds.starts.size() == search_bounds.ends.size()); + + RC_ASSERT(search_bounds.starts[which] < search_bounds.ends[which]); + + std::vector> spans; + for (auto& stream : streams) { + spans.push_back(std::span(stream)); + } + + auto cmp = std::less{}; + auto result = ParallelMerge::split_point_stream_bounds( + spans, cmp, which, search_bounds); + + RC_ASSERT(result.ends[which] > 0); + + const auto& split_point = streams[which][search_bounds.ends[which] - 1]; + + for (size_t s = 0; s < streams.size(); s++) { + RC_ASSERT(result.starts[s] == search_bounds.starts[s]); + RC_ASSERT(result.ends[s] <= search_bounds.ends[s]); + + for (size_t i = result.starts[s]; i < result.ends[s]; i++) { + RC_ASSERT(streams[s][i] <= split_point); + } + } + } +}; + +} // namespace tiledb::algorithm + +namespace rc { + +/** + * @return a generator which generates a list of streams each sorted in + * ascending order + */ +template +Gen> streams() { + auto stream = + gen::map(gen::arbitrary>(), [](std::vector elts) { + std::sort(elts.begin(), elts.end()); + return elts; + }); + return gen::nonEmpty(gen::container>>(stream)); +} + +/** + * Arbitrary `VerifySplitPointStream` input. + * + * Values generated by this satisfy the following properties: + * 1) At least one of the generated `streams` is non-empty. + * 2) `which` is an index of a non-empty stream. + * 3) `search_bounds` has a non-empty range for stream `which`. + */ +template +struct Arbitrary> { + static Gen> arbitrary() { + auto valid_streams = + gen::suchThat(streams(), [](const Streams& streams) { + return std::any_of( + streams.begin(), streams.end(), [](const std::vector& stream) { + return !stream.empty(); + }); + }); + return gen::mapcat(valid_streams, [](Streams streams) { + std::vector which_candidates; + for (size_t s = 0; s < streams.size(); s++) { + if (!streams[s].empty()) { + which_candidates.push_back(s); + } + } + + auto which = gen::elementOf(which_candidates); + + std::vector>> all_stream_bounds; + for (const auto& stream : streams) { + Gen> bounds = gen::apply( + [](uint64_t a, uint64_t b) { + return std::make_pair(std::min(a, b), std::max(a, b)); + }, + gen::inRange(0, stream.size() + 1), + gen::inRange(0, stream.size() + 1)); + all_stream_bounds.push_back(bounds); + } + + Gen>> gen_stream_bounds = + // gen::arbitrary>>(); + gen::exec([all_stream_bounds] { + std::vector> bounds; + for (const auto& stream_bound : all_stream_bounds) { + bounds.push_back(*stream_bound); + } + return bounds; + }); + + return gen::apply( + [](Streams streams, + uint64_t which, + std::vector> bounds) { + MergeUnit search_bounds; + for (size_t s = 0; s < bounds.size(); s++) { + const auto& bound = bounds[s]; + if (s == which && bound.first == bound.second) { + // tweak to ensure that the split point is valid + if (bound.first == 0) { + search_bounds.starts.push_back(0); + search_bounds.ends.push_back(1); + } else { + search_bounds.starts.push_back(bound.first - 1); + search_bounds.ends.push_back(bound.second); + } + } else { + search_bounds.starts.push_back(bound.first); + search_bounds.ends.push_back(bound.second); + } + } + return VerifySplitPointStream{ + .streams = streams, + .which = which, + .search_bounds = search_bounds}; + }, + gen::just(streams), + which, + gen_stream_bounds); + }); + } +}; + +} // namespace rc + +TEST_CASE( + "parallel merge rapidcheck VerifySplitPointStream", + "[algorithm][parallel_merge]") { + rc::prop( + "verify_split_point_stream_bounds", + [](VerifySplitPointStream input) { input.verify(); }); +} + +TEST_CASE("parallel merge example", "[algorithm][parallel_merge]") { std::vector output(20); ParallelMergeOptions options = {.parallel_factor = 4, .min_merge_items = 4}; diff --git a/vcpkg.json b/vcpkg.json index 8b6d524d37c..e21bbcce1bc 100644 --- a/vcpkg.json +++ b/vcpkg.json @@ -65,7 +65,8 @@ { "name": "libfaketime", "platform": "!windows" - } + }, + "rapidcheck" ] }, "tools": { From 0299ca78ee2d60d227bc03bbb86d83080d82f1eb Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 6 Dec 2024 11:42:57 -0500 Subject: [PATCH 014/228] ParallelMergeException --- tiledb/common/algorithm/parallel_merge.h | 30 ++++++++++++++++++++---- 1 file changed, 25 insertions(+), 5 deletions(-) diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h index fed6bb354d0..96094c9042e 100644 --- a/tiledb/common/algorithm/parallel_merge.h +++ b/tiledb/common/algorithm/parallel_merge.h @@ -45,6 +45,13 @@ namespace tiledb::algorithm { +class ParallelMergeException : public tiledb::common::StatusException { + public: + explicit ParallelMergeException(const std::string& detail) + : tiledb::common::StatusException("ParallelMerge", detail) { + } +}; + struct ParallelMergeOptions { uint64_t parallel_factor; uint64_t min_merge_items; @@ -163,6 +170,7 @@ class ParallelMerge { auto stream = tournament.top(); tournament.pop(); + // empty streams are not put on the priority queue assert(!stream.empty()); output[o++] = stream.front(); @@ -250,9 +258,11 @@ class ParallelMerge { // temporarily shrink the split point stream bounds to indicate the // split point auto original_end = search_bounds_.ends[split_point_stream_]; - assert( - search_bounds_.starts[split_point_stream_] < - search_bounds_.ends[split_point_stream_]); + if (search_bounds_.starts[split_point_stream_] >= + search_bounds_.ends[split_point_stream_]) { + throw ParallelMergeException("Internal error: invalid split point"); + } + search_bounds_.ends[split_point_stream_] = (search_bounds_.starts[split_point_stream_] + search_bounds_.ends[split_point_stream_] + 1) / @@ -273,6 +283,12 @@ class ParallelMerge { // the split point has too few tuples // we will include everything we found and advance assert(search_bounds_.num_items() > 0); + + if (search_bounds_.num_items() == 0) { + throw ParallelMergeException( + "Internal error: split point found zero tuples"); + } + remaining_items_ -= num_split_point_items; search_bounds_.starts = split_point_bounds.ends; return SearchStep::MadeProgress; @@ -304,7 +320,8 @@ class ParallelMerge { return; } } - abort(); + throw ParallelMergeException( + "Internal error: advance_split_point_stream"); } }; @@ -318,7 +335,10 @@ class ParallelMerge { switch (step) { case SearchStep::Stalled: stalled++; - assert(stalled < streams.size()); + if (stalled >= streams.size()) { + throw ParallelMergeException( + "Internal error: no split point shrinks bounds"); + } continue; case SearchStep::MadeProgress: stalled = 0; From 804fc6fc57873bda9864a8d5fce3c0970fe1180f Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 6 Dec 2024 15:29:29 -0500 Subject: [PATCH 015/228] VerifyIdentifyMergeUnit --- tiledb/common/algorithm/parallel_merge.h | 9 +- .../algorithm/test/unit_parallel_merge.cc | 104 ++++++++++++++++-- 2 files changed, 102 insertions(+), 11 deletions(-) diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h index 96094c9042e..0d891472760 100644 --- a/tiledb/common/algorithm/parallel_merge.h +++ b/tiledb/common/algorithm/parallel_merge.h @@ -124,6 +124,8 @@ struct MergeUnit { // forward declarations of friend classes for testing template struct VerifySplitPointStream; +template +struct VerifyIdentifyMergeUnit; template > class ParallelMerge { @@ -207,11 +209,11 @@ class ParallelMerge { streams[i].begin() + search_bounds.starts[i], streams[i].begin() + search_bounds.ends[i]); - auto upper_bound = - std::upper_bound( + auto lower_bound = + std::lower_bound( substream.begin(), substream.end(), split_point, cmp); output.ends.push_back( - output.starts[i] + std::distance(substream.begin(), upper_bound)); + output.starts[i] + std::distance(substream.begin(), lower_bound)); } } @@ -443,6 +445,7 @@ class ParallelMerge { // friend declarations for testing friend struct VerifySplitPointStream; + friend struct VerifyIdentifyMergeUnit; public: static std::unique_ptr start( diff --git a/tiledb/common/algorithm/test/unit_parallel_merge.cc b/tiledb/common/algorithm/test/unit_parallel_merge.cc index 2b6eb9a0ab5..313453db1fd 100644 --- a/tiledb/common/algorithm/test/unit_parallel_merge.cc +++ b/tiledb/common/algorithm/test/unit_parallel_merge.cc @@ -84,6 +84,53 @@ struct VerifySplitPointStream { } }; +template +struct VerifyIdentifyMergeUnit { + Streams streams; + uint64_t target_items; + + void verify() { + std::vector> spans; + for (auto& stream : streams) { + spans.push_back(std::span(stream)); + } + + auto cmp = std::less{}; + auto result = + ParallelMerge::identify_merge_unit(spans, &cmp, target_items); + RC_ASSERT(target_items == result->num_items()); + + for (size_t s = 0; s < streams.size(); s++) { + if (streams[s].empty()) { + RC_ASSERT(result->starts[s] == 0); + RC_ASSERT(result->ends[s] == 0); + } else if (result->starts[s] == result->ends[s]) { + // this stream is not used at all, its first item must exceed + // what lies at the boundary for all other streams + for (size_t s2 = 0; s2 < streams.size(); s2++) { + if (result->starts[s2] != result->ends[s2]) { + RC_ASSERT(streams[s][0] >= streams[s2][result->ends[s2] - 1]); + } + } + } else { + // items from this stream in range `[starts[s], ends[s])` are included + // in the merge unit, so everything outside of the merge unit must + // exceed it + auto& bound_item = streams[s][result->ends[s] - 1]; + for (size_t s2 = 0; s2 < streams.size(); s2++) { + if (result->ends[s2] == streams[s2].size()) { + // the entirety of `s2` is included in the merge unit, + // we can infer no relation to `bound_item` + continue; + } else { + RC_ASSERT(bound_item <= streams[s2][result->ends[s2]]); + } + } + } + } + } +}; + } // namespace tiledb::algorithm namespace rc { @@ -102,6 +149,16 @@ Gen> streams() { return gen::nonEmpty(gen::container>>(stream)); } +template +Gen> streams_non_empty() { + return gen::suchThat(streams(), [](const Streams& streams) { + return std::any_of( + streams.begin(), streams.end(), [](const std::vector& stream) { + return !stream.empty(); + }); + }); +} + /** * Arbitrary `VerifySplitPointStream` input. * @@ -113,14 +170,7 @@ Gen> streams() { template struct Arbitrary> { static Gen> arbitrary() { - auto valid_streams = - gen::suchThat(streams(), [](const Streams& streams) { - return std::any_of( - streams.begin(), streams.end(), [](const std::vector& stream) { - return !stream.empty(); - }); - }); - return gen::mapcat(valid_streams, [](Streams streams) { + return gen::mapcat(streams_non_empty(), [](Streams streams) { std::vector which_candidates; for (size_t s = 0; s < streams.size(); s++) { if (!streams[s].empty()) { @@ -184,6 +234,36 @@ struct Arbitrary> { } }; +template +struct Arbitrary> { + static Gen> arbitrary() { + auto fields = + gen::mapcat(streams_non_empty(), [](const Streams streams) { + uint64_t total_items = 0; + for (const auto& stream : streams) { + total_items += stream.size(); + } + return gen::pair( + gen::just(streams), gen::inRange(1, total_items + 1)); + }); + return gen::map(fields, [](std::pair, uint64_t> fields) { + return VerifyIdentifyMergeUnit{ + .streams = fields.first, .target_items = fields.second}; + }); + } +}; + +template <> +void show>( + const VerifyIdentifyMergeUnit& instance, std::ostream& os) { + os << "{" << std::endl; + os << "\t\"streams\": "; + show(instance.streams, os); + os << "," << std::endl; + os << "\t\"target_items\": " << instance.target_items << std::endl; + os << "}"; +} + } // namespace rc TEST_CASE( @@ -194,6 +274,14 @@ TEST_CASE( [](VerifySplitPointStream input) { input.verify(); }); } +TEST_CASE( + "parallel merge rapidcheck VerifyIdentifyMergeUnit", + "[algorithm][parallel_merge]") { + rc::prop( + "verify_split_point_stream_bounds", + [](VerifyIdentifyMergeUnit input) { input.verify(); }); +} + TEST_CASE("parallel merge example", "[algorithm][parallel_merge]") { std::vector output(20); From 0285add7d27f771b59aa6cc930275b33ada18beb Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 6 Dec 2024 16:07:48 -0500 Subject: [PATCH 016/228] VerifyTournamentMerge --- tiledb/common/algorithm/parallel_merge.h | 3 + .../algorithm/test/unit_parallel_merge.cc | 163 ++++++++++++++---- 2 files changed, 128 insertions(+), 38 deletions(-) diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h index 0d891472760..093411a8444 100644 --- a/tiledb/common/algorithm/parallel_merge.h +++ b/tiledb/common/algorithm/parallel_merge.h @@ -126,6 +126,8 @@ template struct VerifySplitPointStream; template struct VerifyIdentifyMergeUnit; +template +struct VerifyTournamentMerge; template > class ParallelMerge { @@ -446,6 +448,7 @@ class ParallelMerge { // friend declarations for testing friend struct VerifySplitPointStream; friend struct VerifyIdentifyMergeUnit; + friend struct VerifyTournamentMerge; public: static std::unique_ptr start( diff --git a/tiledb/common/algorithm/test/unit_parallel_merge.cc b/tiledb/common/algorithm/test/unit_parallel_merge.cc index 313453db1fd..a36b387a944 100644 --- a/tiledb/common/algorithm/test/unit_parallel_merge.cc +++ b/tiledb/common/algorithm/test/unit_parallel_merge.cc @@ -131,6 +131,44 @@ struct VerifyIdentifyMergeUnit { } }; +template +struct VerifyTournamentMerge { + Streams streams; + std::shared_ptr unit; + + void verify() { + auto cmp = std::less{}; + + std::vector output(unit->num_items()); + + // SAFETY: the merge unit will begin writing at index `unit->output_start()` + T* output_ptr = &output[-unit->output_start()]; + + std::vector> spans; + for (size_t s = 0; s < streams.size(); s++) { + auto& stream = streams[s]; + spans.push_back(std::span(stream)); + } + + auto result = + ParallelMerge::tournament_merge(spans, &cmp, unit, output_ptr); + RC_ASSERT(result.ok()); + + // compare against a naive and slow merge + std::vector inputcmp; + inputcmp.reserve(output.size()); + for (size_t s = 0; s < streams.size(); s++) { + inputcmp.insert( + inputcmp.end(), + streams[s].begin() + unit->starts[s], + streams[s].begin() + unit->ends[s]); + } + std::sort(inputcmp.begin(), inputcmp.end()); + + RC_ASSERT(inputcmp == output); + } +}; + } // namespace tiledb::algorithm namespace rc { @@ -159,6 +197,42 @@ Gen> streams_non_empty() { }); } +template +Gen merge_unit(const Streams& streams) { + std::vector>> all_stream_bounds; + for (const auto& stream : streams) { + Gen> bounds = gen::apply( + [](uint64_t a, uint64_t b) { + return std::make_pair(std::min(a, b), std::max(a, b)); + }, + gen::inRange(0, stream.size() + 1), + gen::inRange(0, stream.size() + 1)); + all_stream_bounds.push_back(bounds); + } + + Gen>> gen_stream_bounds = + // gen::arbitrary>>(); + gen::exec([all_stream_bounds] { + std::vector> bounds; + for (const auto& stream_bound : all_stream_bounds) { + bounds.push_back(*stream_bound); + } + return bounds; + }); + + return gen::map( + gen_stream_bounds, [](std::vector> bounds) { + MergeUnit unit; + unit.starts.reserve(bounds.size()); + unit.ends.reserve(bounds.size()); + for (const auto& bound : bounds) { + unit.starts.push_back(bound.first); + unit.ends.push_back(bound.second); + } + return unit; + }); +} + /** * Arbitrary `VerifySplitPointStream` input. * @@ -179,47 +253,19 @@ struct Arbitrary> { } auto which = gen::elementOf(which_candidates); - - std::vector>> all_stream_bounds; - for (const auto& stream : streams) { - Gen> bounds = gen::apply( - [](uint64_t a, uint64_t b) { - return std::make_pair(std::min(a, b), std::max(a, b)); - }, - gen::inRange(0, stream.size() + 1), - gen::inRange(0, stream.size() + 1)); - all_stream_bounds.push_back(bounds); - } - - Gen>> gen_stream_bounds = - // gen::arbitrary>>(); - gen::exec([all_stream_bounds] { - std::vector> bounds; - for (const auto& stream_bound : all_stream_bounds) { - bounds.push_back(*stream_bound); - } - return bounds; - }); + auto search_bounds = merge_unit(streams); return gen::apply( - [](Streams streams, - uint64_t which, - std::vector> bounds) { - MergeUnit search_bounds; - for (size_t s = 0; s < bounds.size(); s++) { - const auto& bound = bounds[s]; - if (s == which && bound.first == bound.second) { + [](Streams streams, uint64_t which, MergeUnit search_bounds) { + for (size_t s = 0; s < streams.size(); s++) { + if (s == which && + search_bounds.starts[s] == search_bounds.ends[s]) { // tweak to ensure that the split point is valid - if (bound.first == 0) { - search_bounds.starts.push_back(0); - search_bounds.ends.push_back(1); + if (search_bounds.starts[s] == 0) { + search_bounds.ends[s] = 1; } else { - search_bounds.starts.push_back(bound.first - 1); - search_bounds.ends.push_back(bound.second); + search_bounds.starts[s] -= 1; } - } else { - search_bounds.starts.push_back(bound.first); - search_bounds.ends.push_back(bound.second); } } return VerifySplitPointStream{ @@ -229,7 +275,7 @@ struct Arbitrary> { }, gen::just(streams), which, - gen_stream_bounds); + search_bounds); }); } }; @@ -253,6 +299,22 @@ struct Arbitrary> { } }; +template +struct Arbitrary> { + static Gen> arbitrary() { + return gen::mapcat(streams(), [](Streams streams) { + auto unit = merge_unit(streams); + return gen::apply( + [](Streams streams, MergeUnit unit) { + return VerifyTournamentMerge{ + .streams = streams, .unit = std::make_shared(unit)}; + }, + gen::just(streams), + unit); + }); + } +}; + template <> void show>( const VerifyIdentifyMergeUnit& instance, std::ostream& os) { @@ -264,6 +326,23 @@ void show>( os << "}"; } +template <> +void show>( + const VerifyTournamentMerge& instance, std::ostream& os) { + os << "{" << std::endl; + os << "\t\"streams\": "; + show(instance.streams, os); + os << "," << std::endl; + os << "\t\"starts\": ["; + show(instance.unit->starts, os); + os << "]" << std::endl; + os << "," << std::endl; + os << "\t\"ends\": ["; + show(instance.unit->ends, os); + os << "]" << std::endl; + os << "}"; +} + } // namespace rc TEST_CASE( @@ -278,10 +357,18 @@ TEST_CASE( "parallel merge rapidcheck VerifyIdentifyMergeUnit", "[algorithm][parallel_merge]") { rc::prop( - "verify_split_point_stream_bounds", + "verify_identify_merge_unit", [](VerifyIdentifyMergeUnit input) { input.verify(); }); } +TEST_CASE( + "parallel merge rapidcheck VerifyTournamentMerge", + "[algorithm][parallel_merge]") { + rc::prop( + "verify_tournament_merge", + [](VerifyTournamentMerge input) { input.verify(); }); +} + TEST_CASE("parallel merge example", "[algorithm][parallel_merge]") { std::vector output(20); From 54cbed85f946050d594c5ea5964a1fd6d1e8818d Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 6 Dec 2024 17:04:41 -0500 Subject: [PATCH 017/228] VerifyParallelMerge --- tiledb/common/algorithm/parallel_merge.cc | 10 ++ tiledb/common/algorithm/parallel_merge.h | 9 +- .../algorithm/test/unit_parallel_merge.cc | 118 ++++++++++++++++++ 3 files changed, 136 insertions(+), 1 deletion(-) diff --git a/tiledb/common/algorithm/parallel_merge.cc b/tiledb/common/algorithm/parallel_merge.cc index 6564237fcd8..51bbefba956 100644 --- a/tiledb/common/algorithm/parallel_merge.cc +++ b/tiledb/common/algorithm/parallel_merge.cc @@ -37,6 +37,16 @@ using namespace tiledb::common; namespace tiledb::algorithm { +std::optional ParallelMergeFuture::await() { + auto maybe_unit = merge_units_.pop(); + if (maybe_unit.has_value()) { + maybe_unit->wait(); + return merge_bounds_[merge_cursor_++]; + } else { + return std::nullopt; + } +} + void ParallelMergeFuture::block() { while (true) { auto unit = merge_units_.pop(); diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h index 093411a8444..5879f2fd95c 100644 --- a/tiledb/common/algorithm/parallel_merge.h +++ b/tiledb/common/algorithm/parallel_merge.h @@ -62,17 +62,24 @@ struct ParallelMergeFuture { tiledb::common::ProducerConsumerQueue merge_units_; + ParallelMergeFuture() + : merge_cursor_(0) { + } + /** * Wait for more data to finish merging. * * @return the bound in the output stream up to which the merge has completed */ - uint64_t await(); + std::optional await(); /** * Wait for all data to finish merging. */ void block(); + + private: + uint64_t merge_cursor_; }; template > diff --git a/tiledb/common/algorithm/test/unit_parallel_merge.cc b/tiledb/common/algorithm/test/unit_parallel_merge.cc index a36b387a944..34d79c57203 100644 --- a/tiledb/common/algorithm/test/unit_parallel_merge.cc +++ b/tiledb/common/algorithm/test/unit_parallel_merge.cc @@ -169,6 +169,65 @@ struct VerifyTournamentMerge { } }; +template +struct VerifyParallelMerge { + Streams streams; + ParallelMergeOptions options; + size_t pool_concurrency; + + void verify() { + auto cmp = std::less{}; + + uint64_t total_items = 0; + for (const auto& stream : streams) { + total_items += stream.size(); + } + + std::vector> spans; + for (auto& stream : streams) { + spans.push_back(std::span(stream)); + } + + // compare against a naive and slow merge + std::vector inputcmp; + { + inputcmp.reserve(total_items); + for (size_t s = 0; s < streams.size(); s++) { + inputcmp.insert(inputcmp.end(), streams[s].begin(), streams[s].end()); + } + std::sort(inputcmp.begin(), inputcmp.end()); + } + + std::vector output(total_items); + + ThreadPool pool(pool_concurrency); + auto future = + parallel_merge(pool, options, spans, cmp, &output[0]); + + std::optional prev_bound; + std::optional bound; + while ((bound = future->await()).has_value()) { + if (prev_bound.has_value()) { + RC_ASSERT(*prev_bound < *bound); + RC_ASSERT(std::equal( + inputcmp.begin() + *prev_bound, + inputcmp.begin() + *bound, + output.begin() + *prev_bound, + output.begin() + *bound)); + } else { + RC_ASSERT(std::equal( + inputcmp.begin(), + inputcmp.begin() + *bound, + output.begin(), + output.begin() + *bound)); + } + prev_bound = bound; + } + + RC_ASSERT(inputcmp == output); + } +}; + } // namespace tiledb::algorithm namespace rc { @@ -233,6 +292,22 @@ Gen merge_unit(const Streams& streams) { }); } +template <> +struct Arbitrary { + static Gen arbitrary() { + auto parallel_factor = gen::inRange(1, 16); + auto min_merge_items = gen::inRange(1, 16 * 1024); + return gen::apply( + [](uint64_t parallel_factor, uint64_t min_merge_items) { + return ParallelMergeOptions{ + .parallel_factor = parallel_factor, + .min_merge_items = min_merge_items}; + }, + parallel_factor, + min_merge_items); + } +}; + /** * Arbitrary `VerifySplitPointStream` input. * @@ -315,6 +390,24 @@ struct Arbitrary> { } }; +template +struct Arbitrary> { + static Gen> arbitrary() { + return gen::apply( + [](Streams streams, + ParallelMergeOptions options, + size_t pool_concurrency) { + return VerifyParallelMerge{ + .streams = streams, + .options = options, + .pool_concurrency = pool_concurrency}; + }, + streams(), + gen::arbitrary(), + gen::inRange(1, 32)); + } +}; + template <> void show>( const VerifyIdentifyMergeUnit& instance, std::ostream& os) { @@ -343,6 +436,23 @@ void show>( os << "}"; } +template <> +void show>( + const VerifyParallelMerge& instance, std::ostream& os) { + os << "{" << std::endl; + os << "\t\"streams\": "; + show(instance.streams, os); + os << "," << std::endl; + os << "\t\"options\": {" << std::endl; + os << "\t\t\"parallel_factor\": " << instance.options.parallel_factor + << std::endl; + os << "\t\t\"min_merge_items\": " << instance.options.min_merge_items + << std::endl; + os << "\t}," << std::endl; + os << "\t\"pool_concurrency\": " << instance.pool_concurrency << std::endl; + os << "}"; +} + } // namespace rc TEST_CASE( @@ -369,6 +479,14 @@ TEST_CASE( [](VerifyTournamentMerge input) { input.verify(); }); } +TEST_CASE( + "parallel merge rapidcheck VerifyParallelMerge", + "[algorithm][parallel_merge]") { + rc::prop("verify_parallel_merge", [](VerifyParallelMerge input) { + input.verify(); + }); +} + TEST_CASE("parallel merge example", "[algorithm][parallel_merge]") { std::vector output(20); From 0183686e5a173053be8eab913c9a91d388efeb9c Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 6 Dec 2024 17:13:20 -0500 Subject: [PATCH 018/228] Add more parallel merge test cases for uint8_t and numbers in range 0,10 --- .../algorithm/test/unit_parallel_merge.cc | 98 ++++++++++++++++++- 1 file changed, 94 insertions(+), 4 deletions(-) diff --git a/tiledb/common/algorithm/test/unit_parallel_merge.cc b/tiledb/common/algorithm/test/unit_parallel_merge.cc index 34d79c57203..94712274c46 100644 --- a/tiledb/common/algorithm/test/unit_parallel_merge.cc +++ b/tiledb/common/algorithm/test/unit_parallel_merge.cc @@ -456,7 +456,7 @@ void show>( } // namespace rc TEST_CASE( - "parallel merge rapidcheck VerifySplitPointStream", + "parallel merge rapidcheck uint64_t VerifySplitPointStream", "[algorithm][parallel_merge]") { rc::prop( "verify_split_point_stream_bounds", @@ -464,7 +464,7 @@ TEST_CASE( } TEST_CASE( - "parallel merge rapidcheck VerifyIdentifyMergeUnit", + "parallel merge rapidcheck uint64_t VerifyIdentifyMergeUnit", "[algorithm][parallel_merge]") { rc::prop( "verify_identify_merge_unit", @@ -472,7 +472,7 @@ TEST_CASE( } TEST_CASE( - "parallel merge rapidcheck VerifyTournamentMerge", + "parallel merge rapidcheck uint64_t VerifyTournamentMerge", "[algorithm][parallel_merge]") { rc::prop( "verify_tournament_merge", @@ -480,13 +480,103 @@ TEST_CASE( } TEST_CASE( - "parallel merge rapidcheck VerifyParallelMerge", + "parallel merge rapidcheck uint64_t VerifyParallelMerge", "[algorithm][parallel_merge]") { rc::prop("verify_parallel_merge", [](VerifyParallelMerge input) { input.verify(); }); } +TEST_CASE( + "parallel merge rapidcheck int8_t VerifySplitPointStream", + "[algorithm][parallel_merge]") { + rc::prop( + "verify_split_point_stream_bounds", + [](VerifySplitPointStream input) { input.verify(); }); +} + +TEST_CASE( + "parallel merge rapidcheck int8_t VerifyIdentifyMergeUnit", + "[algorithm][parallel_merge]") { + rc::prop( + "verify_identify_merge_unit", + [](VerifyIdentifyMergeUnit input) { input.verify(); }); +} + +TEST_CASE( + "parallel merge rapidcheck int8_t VerifyTournamentMerge", + "[algorithm][parallel_merge]") { + rc::prop("verify_tournament_merge", [](VerifyTournamentMerge input) { + input.verify(); + }); +} + +TEST_CASE( + "parallel merge rapidcheck int8_t VerifyParallelMerge", + "[algorithm][parallel_merge]") { + rc::prop("verify_parallel_merge", [](VerifyParallelMerge input) { + input.verify(); + }); +} + +struct OneDigit { + uint8_t value_; + + operator uint8_t() const { + return value_; + } + + /* + bool operator==(const OneDigit& other) const { + return value_ == other.value_; + } + */ +}; + +namespace rc { +template <> +struct Arbitrary { + static Gen arbitrary() { + return gen::map(gen::inRange(0, 10), [](uint8_t value) { + RC_PRE(0 <= value && value < 10); + return OneDigit{.value_ = value}; + }); + } +}; +} // namespace rc + +TEST_CASE( + "parallel merge rapidcheck OneDigit VerifySplitPointStream", + "[algorithm][parallel_merge]") { + rc::prop( + "verify_split_point_stream_bounds", + [](VerifySplitPointStream input) { input.verify(); }); +} + +TEST_CASE( + "parallel merge rapidcheck OneDigit VerifyIdentifyMergeUnit", + "[algorithm][parallel_merge]") { + rc::prop( + "verify_identify_merge_unit", + [](VerifyIdentifyMergeUnit input) { input.verify(); }); +} + +TEST_CASE( + "parallel merge rapidcheck OneDigit VerifyTournamentMerge", + "[algorithm][parallel_merge]") { + rc::prop( + "verify_tournament_merge", + [](VerifyTournamentMerge input) { input.verify(); }); +} + +TEST_CASE( + "parallel merge rapidcheck OneDigit VerifyParallelMerge", + "[algorithm][parallel_merge]") { + rc::prop("verify_parallel_merge", [](VerifyParallelMerge input) { + input.verify(); + }); +} + TEST_CASE("parallel merge example", "[algorithm][parallel_merge]") { std::vector output(20); From da5d191efd8d1566adbc894d9a76110ea11236ec Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 6 Dec 2024 17:15:58 -0500 Subject: [PATCH 019/228] Remove commented-out code --- tiledb/common/algorithm/test/unit_parallel_merge.cc | 6 ------ 1 file changed, 6 deletions(-) diff --git a/tiledb/common/algorithm/test/unit_parallel_merge.cc b/tiledb/common/algorithm/test/unit_parallel_merge.cc index 94712274c46..183a2983169 100644 --- a/tiledb/common/algorithm/test/unit_parallel_merge.cc +++ b/tiledb/common/algorithm/test/unit_parallel_merge.cc @@ -525,12 +525,6 @@ struct OneDigit { operator uint8_t() const { return value_; } - - /* - bool operator==(const OneDigit& other) const { - return value_ == other.value_; - } - */ }; namespace rc { From 1225c2169fb9a56dfd2eaf419a93b491e15b5643 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 9 Dec 2024 09:04:03 -0500 Subject: [PATCH 020/228] Fix exceeding memory budget --- tiledb/sm/query/readers/sparse_global_order_reader.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index adc4e40b263..6b45cbc4dca 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -543,6 +543,8 @@ SparseGlobalOrderReader::create_result_tiles( if (merge_ok_bound == result_tile_cursor_) { // this means we cannot safely produce any results throw SparseGlobalOrderReaderException("TODO"); + } else { + break; } } From 3833eaa3dd92b186606ba5604085011b4b0dc581 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 9 Dec 2024 16:30:01 -0500 Subject: [PATCH 021/228] Add UntypedDatum methods to Range --- tiledb/type/range/range.h | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/tiledb/type/range/range.h b/tiledb/type/range/range.h index 5871dc5230a..53d6dea3400 100644 --- a/tiledb/type/range/range.h +++ b/tiledb/type/range/range.h @@ -37,6 +37,7 @@ #include "tiledb/common/logger_public.h" #include "tiledb/common/pmr.h" #include "tiledb/common/tag.h" +#include "tiledb/common/types/untyped_datum.h" #include "tiledb/sm/enums/datatype.h" #include @@ -352,6 +353,29 @@ class Range { std::memcpy(&range_[fixed_size], end, fixed_size); } + /** + * @return an un-typed non-owning view into the start of the range + */ + UntypedDatumView start_datum() const { + if (var_size_) { + return UntypedDatumView(range_.data(), range_start_size_); + } else { + return UntypedDatumView(start_fixed(), range_.size() / 2); + } + } + + /** + * @return an un-typed non-owning view into the end of the range + */ + UntypedDatumView end_datum() const { + if (var_size_) { + return UntypedDatumView( + range_.data() + range_start_size_, range_.size() - range_start_size_); + } else { + return UntypedDatumView(end_fixed(), range_.size() / 2); + } + } + /** Returns the start range as the requested type. */ template inline T start_as() const { From 5a20d6b7988974301b11c225ff6fa385afeb35cf Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 9 Dec 2024 16:31:00 -0500 Subject: [PATCH 022/228] Refactor GlobalCmp --- tiledb/sm/misc/comparators.h | 219 ++++++++++++++---------- tiledb/sm/query/readers/result_coords.h | 8 + 2 files changed, 138 insertions(+), 89 deletions(-) diff --git a/tiledb/sm/misc/comparators.h b/tiledb/sm/misc/comparators.h index 3bcac5efc1b..5a67b2b7d16 100644 --- a/tiledb/sm/misc/comparators.h +++ b/tiledb/sm/misc/comparators.h @@ -38,6 +38,7 @@ #include #include +#include "tiledb/common/types/untyped_datum.h" #include "tiledb/sm/array_schema/domain.h" #include "tiledb/sm/enums/layout.h" #include "tiledb/sm/query/readers/result_coords.h" @@ -56,46 +57,20 @@ class CellCmpBase { /** The number of dimensions. */ const unsigned dim_num_; - /** Use timestamps or not during comparison. */ - const bool use_timestamps_; - - /** Enforce strict ordering for the comparator if used in a queue. */ - const bool strict_ordering_; - - /** Pointer to access fragment metadata. */ - const std::vector>* frag_md_; - public: - explicit CellCmpBase( - const Domain& domain, - const bool use_timestamps = false, - const bool strict_ordering = false, - const std::vector>* frag_md = nullptr) + explicit CellCmpBase(const Domain& domain) : domain_(domain) - , dim_num_(domain.dim_num()) - , use_timestamps_(use_timestamps) - , strict_ordering_(strict_ordering) - , frag_md_(frag_md) { + , dim_num_(domain.dim_num()) { } - template + template [[nodiscard]] int cell_order_cmp_RC( - unsigned int d, const RCType& a, const RCType& b) const { + unsigned int d, const RCTypeL& a, const RCTypeR& b) const { const auto& dim{*(domain_.dimension_ptr(d))}; auto v1{a.dimension_datum(dim, d)}; auto v2{b.dimension_datum(dim, d)}; return domain_.cell_order_cmp(d, v1, v2); } - - template - uint64_t get_timestamp(const RCType& rc) const { - const auto f = rc.tile_->frag_idx(); - if ((*frag_md_)[f]->has_timestamps()) { - return rc.tile_->timestamp(rc.pos_); - } else { - return (*frag_md_)[f]->timestamp_range().first; - } - } }; /** Wrapper of comparison function for sorting coords on row-major order. */ @@ -161,8 +136,42 @@ class ColCmp : CellCmpBase { } }; +class ResultTileCmpBase : public CellCmpBase { + protected: + /** Use timestamps or not during comparison. */ + const bool use_timestamps_; + + /** Enforce strict ordering for the comparator if used in a queue. */ + const bool strict_ordering_; + + /** Pointer to access fragment metadata. */ + const std::vector>* frag_md_; + + public: + explicit ResultTileCmpBase( + const Domain& domain, + const bool use_timestamps = false, + const bool strict_ordering = false, + const std::vector>* frag_md = nullptr) + : CellCmpBase(domain) + , use_timestamps_(use_timestamps) + , strict_ordering_(strict_ordering) + , frag_md_(frag_md) { + } + + template + uint64_t get_timestamp(const RCType& rc) const { + const auto f = rc.tile_->frag_idx(); + if ((*frag_md_)[f]->has_timestamps()) { + return rc.tile_->timestamp(rc.pos_); + } else { + return (*frag_md_)[f]->timestamp_range().first; + } + } +}; + /** Wrapper of comparison function for sorting coords on Hilbert values. */ -class HilbertCmp : public CellCmpBase { +class HilbertCmp : public ResultTileCmpBase { public: /** Constructor. */ HilbertCmp( @@ -170,7 +179,7 @@ class HilbertCmp : public CellCmpBase { const bool use_timestamps = false, const bool strict_ordering = false, const std::vector>* frag_md = nullptr) - : CellCmpBase(domain, use_timestamps, strict_ordering, frag_md) { + : ResultTileCmpBase(domain, use_timestamps, strict_ordering, frag_md) { } /** @@ -317,39 +326,27 @@ class HilbertCmpRCI : protected CellCmpBase { }; /** - * Wrapper of comparison function for sorting coords on the global order - * of some domain. + * Concept describing types which can be ordered using `GlobalCmp`. */ -class GlobalCmp : public CellCmpBase { +template +concept GlobalCellCmpable = + requires(const T& a, const Dimension& dim, unsigned d) { + { a.coord(d) } -> std::convertible_to; + { a.dimension_datum(dim, d) } -> std::same_as; + { a.fragment_idx() } -> std::convertible_to; + { a.tile_idx() } -> std::convertible_to; + }; + +class GlobalCellCmp : public CellCmpBase { public: - /** - * Constructor. - * - * @param domain The array domain. - * @param use_timestamps Use timestamps or not for this comparator. - * @param strict_ordering Enforce strict ordering for the comparator if used - * in a queue. - * @param frag_md Pointer to the fragment metadata. - */ - explicit GlobalCmp( - const Domain& domain, - const bool use_timestamps = false, - const bool strict_ordering = false, - const std::vector>* frag_md = nullptr) - : CellCmpBase(domain, use_timestamps, strict_ordering, frag_md) { - tile_order_ = domain.tile_order(); - cell_order_ = domain.cell_order(); + GlobalCellCmp(const Domain& domain) + : CellCmpBase(domain) + , tile_order_(domain.tile_order()) + , cell_order_(domain.cell_order()) { } - /** - * Comparison operator for a vector of `ResultCoords`. - * - * @param a The first coordinate. - * @param b The second coordinate. - * @return `true` if `a` precedes `b` and `false` otherwise. - */ - template - bool operator()(const RCType& a, const RCType& b) const { + template + int compare(const GlobalCmpL& a, const GlobalCmpR& b) const { if (tile_order_ == Layout::ROW_MAJOR) { for (unsigned d = 0; d < dim_num_; ++d) { // Not applicable to var-sized dimensions @@ -357,11 +354,9 @@ class GlobalCmp : public CellCmpBase { continue; auto res = domain_.tile_order_cmp(d, a.coord(d), b.coord(d)); - - if (res == -1) - return true; - if (res == 1) - return false; + if (res != 0) { + return res; + } // else same tile on dimension d --> continue } } else { // COL_MAJOR @@ -372,11 +367,9 @@ class GlobalCmp : public CellCmpBase { continue; auto res = domain_.tile_order_cmp(d, a.coord(d), b.coord(d)); - - if (res == -1) - return true; - if (res == 1) - return false; + if (res != 0) { + return res; + } // else same tile on dimension d --> continue } } @@ -385,49 +378,97 @@ class GlobalCmp : public CellCmpBase { if (cell_order_ == Layout::ROW_MAJOR) { for (unsigned d = 0; d < dim_num_; ++d) { auto res = cell_order_cmp_RC(d, a, b); - - if (res == -1) - return true; - if (res == 1) - return false; + if (res != 0) { + return res; + } // else same tile on dimension d --> continue } } else { // COL_MAJOR assert(cell_order_ == Layout::COL_MAJOR); for (int32_t d = static_cast(dim_num_) - 1; d >= 0; d--) { auto res = cell_order_cmp_RC(d, a, b); - - if (res == -1) - return true; - if (res == 1) - return false; + if (res != 0) { + return res; + } // else same tile on dimension d --> continue } } + return 0; + } + + template + bool operator()(const GlobalCmpL& a, const GlobalCmpR& b) const { + return compare(a, b) < 0; + } + + private: + /** The tile order. */ + Layout tile_order_; + /** The cell order. */ + Layout cell_order_; +}; + +/** + * Wrapper of comparison function for sorting coords on the global order + * of some domain. + */ +class GlobalCmp : public ResultTileCmpBase { + public: + /** + * Constructor. + * + * @param domain The array domain. + * @param use_timestamps Use timestamps or not for this comparator. + * @param strict_ordering Enforce strict ordering for the comparator if used + * in a queue. + * @param frag_md Pointer to the fragment metadata. + */ + explicit GlobalCmp( + const Domain& domain, + const bool use_timestamps = false, + const bool strict_ordering = false, + const std::vector>* frag_md = nullptr) + : ResultTileCmpBase(domain, use_timestamps, strict_ordering, frag_md) + , cellcmp_(domain) { + } + + /** + * Comparison operator for a vector of `GlobalCellCmpable`. + * + * @param a The first coordinate. + * @param b The second coordinate. + * @return `true` if `a` precedes `b` and `false` otherwise. + */ + template + bool operator()(const GlobalCmpL& a, const GlobalCmpR& b) const { + const int cellcmp = cellcmp_.compare(a, b); + if (cellcmp < 0) { + return true; + } else if (cellcmp > 0) { + return false; + } + // Compare timestamps if (use_timestamps_) { return get_timestamp(a) > get_timestamp(b); } else if (strict_ordering_) { - if (a.tile_->frag_idx() == b.tile_->frag_idx()) { - if (a.tile_->tile_idx() == b.tile_->tile_idx()) { + if (a.fragment_idx() == b.fragment_idx()) { + if (a.tile_idx() == b.tile_idx()) { return a.pos_ > b.pos_; } - return a.tile_->tile_idx() > b.tile_->tile_idx(); + return a.tile_idx() > b.tile_idx(); } - return a.tile_->frag_idx() > b.tile_->frag_idx(); + return a.fragment_idx() > b.fragment_idx(); } return false; } private: - /** The tile order. */ - Layout tile_order_; - /** The cell order. */ - Layout cell_order_; + GlobalCellCmp cellcmp_; }; /** diff --git a/tiledb/sm/query/readers/result_coords.h b/tiledb/sm/query/readers/result_coords.h index f835002a946..7f34535f84a 100644 --- a/tiledb/sm/query/readers/result_coords.h +++ b/tiledb/sm/query/readers/result_coords.h @@ -77,6 +77,14 @@ struct ResultCoordsBase { , pos_(pos) { } + unsigned fragment_idx() const { + return tile_->frag_idx(); + } + + uint64_t tile_idx() const { + return tile_->tile_idx(); + } + /** * Returns a string coordinate. Applicable only to string * dimensions. From 3c6e4b23cad2b3c8be7fadf8266d0d246734d896 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 9 Dec 2024 16:35:29 -0500 Subject: [PATCH 023/228] Add fragment skew, fragment interleave tests --- test/src/unit-sparse-global-order-reader.cc | 259 +++++++++++++++++++- 1 file changed, 257 insertions(+), 2 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 2168715f5da..a29529f6655 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -101,10 +101,27 @@ struct CSparseGlobalOrderFx { void reset_config(); void update_config(); + std::string error_if_any() const; + CSparseGlobalOrderFx(); ~CSparseGlobalOrderFx(); }; +std::string CSparseGlobalOrderFx::error_if_any() const { + tiledb_error_t* error = NULL; + auto rc = tiledb_ctx_get_last_error(ctx_, &error); + REQUIRE(rc == TILEDB_OK); + if (error == nullptr) { + return ""; + } + + const char* msg; + rc = tiledb_error_message(error, &msg); + REQUIRE(rc == TILEDB_OK); + + return std::string(msg); +} + CSparseGlobalOrderFx::CSparseGlobalOrderFx() { reset_config(); @@ -705,6 +722,242 @@ TEST_CASE_METHOD( CHECK(retrieved_data == expected_correct_data); } +/** + * Tests that the reader will not yield results out of order across multiple + * iterations or `submit`s if the fragments are heavily skewed when the memory + * budget is heavily constrained. + * + * e.g. two fragments + * F0: 1-1000,1001-2000,2001-3000 + * F1: 2001-3000 + * + * If the memory budget allows only one tile per fragment at a time then there + * must be a mechanism for emitting (F0, T1) before (F1, T0) even though the + * the memory budget might not process them in the same loop. + */ +TEST_CASE_METHOD( + CSparseGlobalOrderFx, + "Sparse global order reader: fragment skew", + "[sparse-global-order]") { + reset_config(); + + // the tile extent is 2 + create_default_array_1d(true); + + // Write a fragment F0 with unique coordinates + std::vector f0coords(200); + std::iota(f0coords.begin(), f0coords.end(), 1); + uint64_t f0coords_size = f0coords.size() * sizeof(int); + + // Write a fragment F1 with lots of duplicates + // [100,100,100,100,100,101,101,101,101,101,102,102,102,102,102,...] + std::vector f1coords(200); + for (size_t i = 0; i < f1coords.size(); i++) { + f1coords[i] = static_cast(i / 10) + 100; + } + uint64_t f1coords_size = f1coords.size() * sizeof(int); + + std::vector att(200); + std::iota(att.begin(), att.end(), 200); + uint64_t att_size = att.size() * sizeof(int); + + write_1d_fragment(f0coords.data(), &f0coords_size, att.data(), &att_size); + REQUIRE(f0coords_size == f0coords.size() * sizeof(int)); + REQUIRE(att_size == att.size() * sizeof(int)); + + write_1d_fragment(f1coords.data(), &f1coords_size, att.data(), &att_size); + REQUIRE(f1coords_size == f1coords.size() * sizeof(int)); + REQUIRE(att_size == att.size() * sizeof(int)); + + /** + * Now we should have 200 tiles, each of which has 2 coordinates, + * and each of which is size is 1584. + * In global order we skew towards fragment 1 which has lots of duplicates. + */ + total_budget_ = "20000"; + ratio_array_data_ = "0.5"; + update_config(); + + std::vector outcoords(400); + std::vector outatt(400); + + // Open array for reading. + tiledb_array_t* array; + auto rc = tiledb_array_alloc(ctx_, array_name_.c_str(), &array); + CHECK(rc == TILEDB_OK); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); + CHECK(rc == TILEDB_OK); + + // Create query + tiledb_query_t* query; + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); + CHECK(rc == TILEDB_OK); + rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); + CHECK(rc == TILEDB_OK); + + constexpr size_t num_output_cells_per_iter = 8; + + uint64_t outcursor = 0; + while (true) { + uint64_t outcoords_size; + uint64_t outatt_size; + outcoords_size = outatt_size = num_output_cells_per_iter * sizeof(int); + + rc = tiledb_query_set_data_buffer( + ctx_, query, "a", &outatt[outcursor], &outatt_size); + CHECK(rc == TILEDB_OK); + rc = tiledb_query_set_data_buffer( + ctx_, query, "d", &outcoords[outcursor], &outcoords_size); + CHECK(rc == TILEDB_OK); + + rc = tiledb_query_submit(ctx_, query); + REQUIRE("" == error_if_any()); + + CHECK(outcoords_size == num_output_cells_per_iter * sizeof(int)); + outcursor += num_output_cells_per_iter; + + tiledb_query_status_t status; + rc = tiledb_query_get_status(ctx_, query, &status); + REQUIRE(rc == TILEDB_OK); + if (status == TILEDB_COMPLETED) { + break; + } + } + + // Clean up. + rc = tiledb_array_close(ctx_, array); + CHECK(rc == TILEDB_OK); + tiledb_array_free(&array); + tiledb_query_free(&query); + + std::vector expectcoords; + expectcoords.insert(expectcoords.end(), f0coords.begin(), f0coords.end()); + expectcoords.insert(expectcoords.end(), f1coords.begin(), f1coords.end()); + std::sort(expectcoords.begin(), expectcoords.end()); + + CHECK(expectcoords == outcoords); +} + +/** + * Tests that the reader will not yield results out of order across multiple + * iterations or `submit`s if the tile MBRs across different fragments are + * interleaved. + * + * The test sets up data with two fragments so that each tile overlaps with + * two tiles from the other fragment. This way when the tiles are arranged + * in global order the only way to ensure that we don't emit out of order + * results with a naive implementation is to have *all* the tiles loaded + * in one pass, which is not practical. + * + * TODO: + */ +TEST_CASE_METHOD( + CSparseGlobalOrderFx, + "Sparse global order reader: fragment interleave", + "[sparse-global-order]") { + reset_config(); + + // the tile extent is 2 + create_default_array_1d(true); + + // Write a fragment F0 with tiles + // [1,3][3,5][5,7][7,9]... + std::vector f0coords(180); + f0coords[0] = 1; + for (size_t i = 1; i < f0coords.size(); i++) { + f0coords[i] = 1 + 2 * ((i + 1) / 2); + } + uint64_t f0coords_size = f0coords.size() * sizeof(int); + + // Write a fragment F1 with tiles + // [2,4][4,6][6,8][8,10]... + std::vector f1coords(f0coords.size()); + for (size_t i = 0; i < f1coords.size(); i++) { + f1coords[i] = f0coords[i] + 1; + } + uint64_t f1coords_size = f1coords.size() * sizeof(int); + + std::vector att(f0coords.size()); + std::iota(att.begin(), att.end(), f0coords.size()); + uint64_t att_size = att.size() * sizeof(int); + + write_1d_fragment(f0coords.data(), &f0coords_size, att.data(), &att_size); + REQUIRE(f0coords_size == f0coords.size() * sizeof(int)); + REQUIRE(att_size == att.size() * sizeof(int)); + + write_1d_fragment(f1coords.data(), &f1coords_size, att.data(), &att_size); + REQUIRE(f1coords_size == f1coords.size() * sizeof(int)); + REQUIRE(att_size == att.size() * sizeof(int)); + + /** + * Now we should have 200 tiles, each of which has 2 coordinates, + * and each of which is size is 1584. + * In global order we skew towards fragment 1 which has lots of duplicates. + */ + total_budget_ = "20000"; + ratio_array_data_ = "0.5"; + update_config(); + + std::vector outcoords(f0coords.size() + f1coords.size()); + std::vector outatt(outcoords.size()); + + // Open array for reading. + tiledb_array_t* array; + auto rc = tiledb_array_alloc(ctx_, array_name_.c_str(), &array); + CHECK(rc == TILEDB_OK); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); + CHECK(rc == TILEDB_OK); + + // Create query + tiledb_query_t* query; + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); + CHECK(rc == TILEDB_OK); + rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); + CHECK(rc == TILEDB_OK); + + constexpr size_t num_output_cells_per_iter = 8; + + uint64_t outcursor = 0; + while (true) { + uint64_t outcoords_size; + uint64_t outatt_size; + outcoords_size = outatt_size = num_output_cells_per_iter * sizeof(int); + + rc = tiledb_query_set_data_buffer( + ctx_, query, "a", &outatt[outcursor], &outatt_size); + CHECK(rc == TILEDB_OK); + rc = tiledb_query_set_data_buffer( + ctx_, query, "d", &outcoords[outcursor], &outcoords_size); + CHECK(rc == TILEDB_OK); + + rc = tiledb_query_submit(ctx_, query); + REQUIRE("" == error_if_any()); + + CHECK(outcoords_size == num_output_cells_per_iter * sizeof(int)); + outcursor += num_output_cells_per_iter; + + tiledb_query_status_t status; + rc = tiledb_query_get_status(ctx_, query, &status); + REQUIRE(rc == TILEDB_OK); + if (status == TILEDB_COMPLETED) { + break; + } + } + + // Clean up. + rc = tiledb_array_close(ctx_, array); + CHECK(rc == TILEDB_OK); + tiledb_array_free(&array); + tiledb_query_free(&query); + + std::vector expectcoords; + expectcoords.insert(expectcoords.end(), f0coords.begin(), f0coords.end()); + expectcoords.insert(expectcoords.end(), f1coords.begin(), f1coords.end()); + std::sort(expectcoords.begin(), expectcoords.end()); + + CHECK(expectcoords == outcoords); +} + TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: tile offsets budget exceeded", @@ -762,10 +1015,10 @@ TEST_CASE_METHOD( create_default_array_1d(); bool use_subarray = false; - SECTION("- No subarray") { + SECTION("No subarray") { use_subarray = false; } - SECTION("- Subarray") { + SECTION("Subarray") { use_subarray = true; } @@ -789,6 +1042,7 @@ TEST_CASE_METHOD( write_1d_fragment(coords, &coords_size, data, &data_size); } + // FIXME: there is no per fragment budget anymore // Two result tile (2 * (~3000 + 8) will be bigger than the per fragment // budget (1000). total_budget_ = "35000"; @@ -1312,6 +1566,7 @@ TEST_CASE_METHOD( write_1d_fragment(coords, &coords_size, data, &data_size); } + // FIXME: there is no per fragment budget anymore // Two result tile (2 * (~4000 + 8) will be bigger than the per fragment // budget (1000). total_budget_ = "40000"; From d281adbcdbd1a07e5bfee0ea76566f1c5f4180ec Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 9 Dec 2024 16:36:29 -0500 Subject: [PATCH 024/228] Compare against next tile MBR in add_next_cell_to_queue --- .../readers/sparse_global_order_reader.cc | 78 +++++++++++++------ 1 file changed, 55 insertions(+), 23 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 6b45cbc4dca..6fa3998d79d 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -512,16 +512,8 @@ SparseGlobalOrderReader::create_result_tiles( } if (result_tile_cursor_ < result_tile_ids_.size()) { - // FIXME: - // when there is a real budget constraint we will probably - // have to peek at the result tile MBRs to make sure that - // what gets put in `result_tiles` are fully disjoint with - // tiles from other fragments that *don't* get put in `result_tiles`. - // this will be necessary for the merge later on to prevent - // a subsequent `submit` from getting out of order data. - size_t merge_ok_bound = result_tile_cursor_; - - for (size_t rt = result_tile_cursor_; rt < result_tile_ids_.size(); rt++) { + size_t rt; + for (rt = result_tile_cursor_; rt < result_tile_ids_.size(); rt++) { const auto f = result_tile_ids_[rt].fragment_idx_; const auto t = result_tile_ids_[rt].tile_idx_; @@ -540,28 +532,19 @@ SparseGlobalOrderReader::create_result_tiles( f, t); - if (merge_ok_bound == result_tile_cursor_) { + if (rt == result_tile_cursor_) { // this means we cannot safely produce any results throw SparseGlobalOrderReaderException("TODO"); } else { + // this tile has the lowest MBR lower bound of the remaining tiles, + // we cannot safely emit cells exceeding its lower bound later break; } } - - // FIXME: see comment above - // really what we need to do is flip the iteration to identify the merge - // ok units, and then see if we can fit *all* of them within the memory - // budget - merge_ok_bound++; - } - - if (merge_ok_bound == result_tile_cursor_) { - // cannot progress - throw SparseGlobalOrderReaderException("TODO"); } // update position for next iteration - result_tile_cursor_ = merge_ok_bound; + result_tile_cursor_ = rt; if (result_tile_cursor_ == result_tile_ids_.size()) { // TODO: original version sets a flag in tmp_read_state_ on a per-fragment @@ -928,6 +911,55 @@ bool SparseGlobalOrderReader::add_next_cell_to_queue( frag_idx, rc, result_tiles)) { return true; } + + // If the cell value exceeds the lower bound of the un-populated result + // tiles then it is not correct to emit it; hopefully we cleared out + // a tile somewhere and trying again will make progress + if (result_tile_cursor_ < result_tile_ids_.size()) { + const auto& next_global_order_tile = + result_tile_ids_[result_tile_cursor_]; + const auto& emit_bound = + fragment_metadata_[next_global_order_tile.fragment_idx_]->mbr( + next_global_order_tile.tile_idx_); + + // Skip comparison if the next one is the same fragment, + // in that case we know the cells are ordered correctly + if (frag_idx != next_global_order_tile.fragment_idx_) { + struct FutureResultTileLowerBound { + const ResultTileId& tile; + const NDRange& mbr; + + const void* coord(unsigned dim) const { + return mbr[dim].data(); + } + + UntypedDatumView dimension_datum( + const Dimension&, unsigned dim) const { + return mbr[dim].start_datum(); + } + + unsigned fragment_idx() const { + return tile.fragment_idx_; + } + + uint64_t tile_idx() const { + return tile.tile_idx_; + } + }; + + FutureResultTileLowerBound target = { + .tile = next_global_order_tile, .mbr = emit_bound}; + + GlobalCellCmp cmp(array_schema_.domain()); + + if (cmp(target, rc)) { + // more tiles needed, out-of-order tiles is a possibility if we + // continue + return true; + } + } + } + std::unique_lock ul(tile_queue_mutex_); // Add all the cells in this tile with the same coordinates as this cell From b43381da995c9afaa8d6ab425920c3439878e4d8 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 9 Dec 2024 22:06:15 -0500 Subject: [PATCH 025/228] Fill in memory budget exception --- tiledb/sm/query/readers/sparse_global_order_reader.cc | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 6fa3998d79d..7ff1486914e 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -534,7 +534,12 @@ SparseGlobalOrderReader::create_result_tiles( if (rt == result_tile_cursor_) { // this means we cannot safely produce any results - throw SparseGlobalOrderReaderException("TODO"); + const auto tiles_size = get_coord_tiles_size(num_dims, f, t); + throw SparseGlobalOrderReaderException( + "Cannot load a single tile, increase memory budget: " + "next tile size = " + + std::to_string(tiles_size) + ", total_budget = " + + std::to_string(memory_budget_.total_budget())); } else { // this tile has the lowest MBR lower bound of the remaining tiles, // we cannot safely emit cells exceeding its lower bound later From d2d06fac63f51af9fc765bcfa07e335f9168507c Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 9 Dec 2024 22:06:25 -0500 Subject: [PATCH 026/228] Add TODO for test case --- tiledb/sm/query/readers/sparse_global_order_reader.cc | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 7ff1486914e..26ee0c598cc 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -960,6 +960,14 @@ bool SparseGlobalOrderReader::add_next_cell_to_queue( if (cmp(target, rc)) { // more tiles needed, out-of-order tiles is a possibility if we // continue + + // TODO: make sure we have test coverage here. + // 1) scenario where this does not guarantee progress, i.e. + // too many overlapping tiles, we can't emit anything else + // and increasing memory budget really is the only way out + // 2) scenario where this does make progress because we + // finish a tile and thus gain budget to load the next one + return true; } } From a55ddf3cfa1e496d1c4d5ec87fe3d99a751907f9 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 10 Dec 2024 10:44:20 -0500 Subject: [PATCH 027/228] tdb::pmr::emplace_unique --- tiledb/common/pmr.h | 45 ++++++++++++++++++++++++++++++++------------- 1 file changed, 32 insertions(+), 13 deletions(-) diff --git a/tiledb/common/pmr.h b/tiledb/common/pmr.h index dccbd15a650..0eafbab640c 100644 --- a/tiledb/common/pmr.h +++ b/tiledb/common/pmr.h @@ -75,24 +75,30 @@ class unique_ptr_deleter { public: unique_ptr_deleter() = delete; - unique_ptr_deleter(memory_resource* resource, size_t size, size_t alignment) + unique_ptr_deleter(memory_resource* resource, size_t nmemb, size_t alignment) : resource_(resource) - , size_(size) + , nmemb_(nmemb) , alignment_(alignment) { } void operator()(Tp* ptr) { - if (ptr != nullptr) { - resource_->deallocate(ptr, size_, alignment_); + if (ptr == nullptr) { + return; + } + if (!std::is_trivially_destructible::value) { + // destruct in reverse order since the elements are constructed in + // forwards order + for (size_t i = nmemb_; i > 0; i--) { + ptr[i - 1].~Tp(); + } } - } - void set_size(size_t size) { - size_ = size; + const size_t dealloc_size = nmemb_ * sizeof(Tp); + resource_->deallocate(ptr, dealloc_size, alignment_); } memory_resource* resource_; - size_t size_; + size_t nmemb_; size_t alignment_; }; @@ -101,24 +107,37 @@ using unique_ptr = std::unique_ptr>; template unique_ptr make_unique( - memory_resource* resource, size_t size, size_t alignment) { + memory_resource* resource, size_t nmemb, size_t alignment) { static_assert(std::is_arithmetic_v || std::is_same_v); - auto alloc_size = size * sizeof(Tp); + auto alloc_size = nmemb * sizeof(Tp); Tp* data = static_cast(resource->allocate(alloc_size, alignment)); if (data == nullptr) { throw std::bad_alloc(); } - auto deleter = unique_ptr_deleter(resource, alloc_size, alignment); + auto deleter = unique_ptr_deleter(resource, nmemb, alignment); return std::unique_ptr>(data, deleter); } template -unique_ptr make_unique(memory_resource* resource, size_t size) { - return make_unique(resource, size, alignof(Tp)); +unique_ptr make_unique(memory_resource* resource, size_t nmemb) { + return make_unique(resource, nmemb, alignof(Tp)); +} + +/** + * Constructs an object in place and returns it in a `unique_ptr`. + */ +template +unique_ptr emplace_unique(memory_resource* resource, Args&&... args) { + Tp* obj = static_cast(resource->allocate(sizeof(Tp), alignof(Tp))); + new (obj) Tp(std::forward(args)...); + + auto deleter = unique_ptr_deleter(resource, 1, alignof(Tp)); + + return std::unique_ptr>(obj, deleter); } /* ********************************* */ From fc8936e5fc15628623dda7545f5330c0eded17fd Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 10 Dec 2024 10:51:04 -0500 Subject: [PATCH 028/228] Use pmr in parallel merge --- tiledb/common/algorithm/parallel_merge.cc | 29 +-- tiledb/common/algorithm/parallel_merge.h | 184 +++++++++++------- tiledb/common/algorithm/test/CMakeLists.txt | 1 + .../algorithm/test/unit_parallel_merge.cc | 109 +++++++---- tiledb/common/memory_tracker.cc | 2 + tiledb/common/memory_tracker.h | 1 + .../readers/sparse_global_order_reader.cc | 8 +- 7 files changed, 215 insertions(+), 119 deletions(-) diff --git a/tiledb/common/algorithm/parallel_merge.cc b/tiledb/common/algorithm/parallel_merge.cc index 51bbefba956..4ca7071a069 100644 --- a/tiledb/common/algorithm/parallel_merge.cc +++ b/tiledb/common/algorithm/parallel_merge.cc @@ -37,25 +37,30 @@ using namespace tiledb::common; namespace tiledb::algorithm { +ParallelMergeFuture::ParallelMergeFuture( + ParallelMergeMemoryResources& memory, size_t parallel_factor) + : memory_(memory) + , merge_bounds_(&memory.control) + , merge_cursor_(0) { + merge_bounds_.reserve(parallel_factor); + for (size_t p = 0; p < parallel_factor; p++) { + merge_bounds_.push_back(MergeUnit(memory.control)); + } +} + std::optional ParallelMergeFuture::await() { - auto maybe_unit = merge_units_.pop(); - if (maybe_unit.has_value()) { - maybe_unit->wait(); - return merge_bounds_[merge_cursor_++]; + auto maybe_task = merge_tasks_.pop(); + if (maybe_task.has_value()) { + maybe_task->wait(); + return merge_bounds_[merge_cursor_++].output_end(); } else { return std::nullopt; } } void ParallelMergeFuture::block() { - while (true) { - auto unit = merge_units_.pop(); - if (!unit.has_value()) { - break; - } else { - unit->wait(); - } - } + while (await().has_value()) + ; } } // namespace tiledb::algorithm diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h index 5879f2fd95c..dec2a517ce7 100644 --- a/tiledb/common/algorithm/parallel_merge.h +++ b/tiledb/common/algorithm/parallel_merge.h @@ -36,6 +36,8 @@ #ifndef TILEDB_PARALLEL_MERGE_H #define TILEDB_PARALLEL_MERGE_H +#include "tiledb/common/memory_tracker.h" +#include "tiledb/common/pmr.h" #include "tiledb/common/status.h" #include "tiledb/common/thread_pool/producer_consumer_queue.h" #include "tiledb/common/thread_pool/thread_pool.h" @@ -52,24 +54,53 @@ class ParallelMergeException : public tiledb::common::StatusException { } }; +/** + * Options for running the parallel merge. + */ struct ParallelMergeOptions { + // Maximum number of parallel tasks to submit. uint64_t parallel_factor; + + // Minimum number of items to merge in each parallel task. uint64_t min_merge_items; }; +struct ParallelMergeMemoryResources { + // Memory resource for allocating parallel merge control structures. + tdb::pmr::memory_resource& control; + + ParallelMergeMemoryResources(tiledb::sm::MemoryTracker& memory_tracker) + : control(*memory_tracker.get_resource( + tiledb::sm::MemoryType::PARALLEL_MERGE_CONTROL)) { + } +}; + +struct MergeUnit; + +/** + * The output future of the parallel merge. + * + * Provides methods for waiting on the incremental asynchronous output + * of the merge operation. + * + * FIXME: need to move the comparator here somehow so that way + * it doesn't have to have a longer lifetime from the caller + */ struct ParallelMergeFuture { - std::vector merge_bounds_; - tiledb::common::ProducerConsumerQueue - merge_units_; + ParallelMergeFuture( + ParallelMergeMemoryResources& memory, size_t parallel_factor); - ParallelMergeFuture() - : merge_cursor_(0) { + /** + * @return memory resource used for parallel merge control structures + */ + tdb::pmr::memory_resource& control_memory() const { + return memory_.control; } /** * Wait for more data to finish merging. * - * @return the bound in the output stream up to which the merge has completed + * @return the bound in the output buffer up to which the merge has completed */ std::optional await(); @@ -79,11 +110,21 @@ struct ParallelMergeFuture { void block(); private: + ParallelMergeMemoryResources memory_; + + tdb::pmr::vector merge_bounds_; + tiledb::common::ProducerConsumerQueue + merge_tasks_; + + // index of the next expected item in `merge_bounds_` uint64_t merge_cursor_; + + template + friend class ParallelMerge; }; template > -std::unique_ptr parallel_merge( +tdb::pmr::unique_ptr parallel_merge( tiledb::common::ThreadPool& pool, const ParallelMergeOptions& options, std::span> streams, @@ -96,8 +137,13 @@ std::unique_ptr parallel_merge( * This unit writes to the output in the range [sum(starts), sum(ends)]. */ struct MergeUnit { - std::vector starts; - std::vector ends; + tdb::pmr::vector starts; + tdb::pmr::vector ends; + + MergeUnit(tdb::pmr::memory_resource& resource) + : starts(&resource) + , ends(&resource) { + } uint64_t num_items() const { uint64_t total_items = 0; @@ -155,10 +201,7 @@ class ParallelMerge { }; static Status tournament_merge( - Streams streams, - Compare* cmp, - std::shared_ptr unit, - T* output) { + Streams streams, Compare* cmp, const MergeUnit& unit, T* output) { std::vector> container; container.reserve(streams.size()); @@ -169,13 +212,13 @@ class ParallelMerge { tournament(span_greater(*cmp), container); for (size_t i = 0; i < streams.size(); i++) { - if (unit->starts[i] != unit->ends[i]) { - tournament.push(streams[i].subspan( - unit->starts[i], unit->ends[i] - unit->starts[i])); + if (unit.starts[i] != unit.ends[i]) { + tournament.push( + streams[i].subspan(unit.starts[i], unit.ends[i] - unit.starts[i])); } } - size_t o = unit->output_start(); + size_t o = unit.output_start(); while (!tournament.empty()) { auto stream = tournament.top(); @@ -191,7 +234,7 @@ class ParallelMerge { } } - if (o == unit->output_end()) { + if (o == unit.output_end()) { return tiledb::common::Status::Ok(); } else { return tiledb::common::Status_Error("Internal error in parallel merge"); @@ -201,11 +244,12 @@ class ParallelMerge { static MergeUnit split_point_stream_bounds( Streams streams, Compare& cmp, + tdb::pmr::memory_resource& memory, uint64_t which, const MergeUnit& search_bounds) { const T& split_point = streams[which][search_bounds.ends[which] - 1]; - MergeUnit output; + MergeUnit output(memory); output.starts = search_bounds.starts; output.ends.reserve(streams.size()); @@ -234,25 +278,33 @@ class ParallelMerge { struct SearchMergeBoundary { Streams streams_; Compare& cmp_; + tdb::pmr::memory_resource& memory_; uint64_t split_point_stream_; uint64_t remaining_items_; MergeUnit search_bounds_; - SearchMergeBoundary(Streams streams, Compare& cmp, uint64_t target_items) + SearchMergeBoundary( + Streams streams, + Compare& cmp, + tdb::pmr::memory_resource& memory, + uint64_t target_items) : streams_(streams) , cmp_(cmp) + , memory_(memory) , split_point_stream_(0) - , remaining_items_(target_items) { - search_bounds_.starts = std::vector(streams.size(), 0); + , remaining_items_(target_items) + , search_bounds_(memory) { + search_bounds_.starts.reserve(streams.size()); search_bounds_.ends.reserve(streams.size()); for (const auto& stream : streams) { + search_bounds_.starts.push_back(0); search_bounds_.ends.push_back(stream.size()); } } MergeUnit current() const { - MergeUnit m; - m.starts = std::vector(search_bounds_.starts.size(), 0); + MergeUnit m(memory_); + m.starts.resize(search_bounds_.starts.size(), 0); m.ends = search_bounds_.ends; return m; } @@ -264,7 +316,7 @@ class ParallelMerge { advance_split_point_stream(); - MergeUnit split_point_bounds; + MergeUnit split_point_bounds(memory_); { // temporarily shrink the split point stream bounds to indicate the // split point @@ -280,7 +332,7 @@ class ParallelMerge { 2; split_point_bounds = split_point_stream_bounds( - streams_, cmp_, split_point_stream_, search_bounds_); + streams_, cmp_, memory_, split_point_stream_, search_bounds_); search_bounds_.ends[split_point_stream_] = original_end; } @@ -336,9 +388,12 @@ class ParallelMerge { } }; - static std::shared_ptr identify_merge_unit( - Streams streams, Compare* cmp, uint64_t target_items) { - SearchMergeBoundary search(streams, *cmp, target_items); + static MergeUnit identify_merge_unit( + Streams streams, + Compare* cmp, + tdb::pmr::memory_resource& memory, + uint64_t target_items) { + SearchMergeBoundary search(streams, *cmp, memory, target_items); uint64_t stalled = 0; while (true) { @@ -355,7 +410,7 @@ class ParallelMerge { stalled = 0; continue; case SearchStep::Converged: - return std::make_shared(search.current()); + return search.current(); } } } @@ -368,33 +423,26 @@ class ParallelMerge { uint64_t total_items, uint64_t target_unit_size, uint64_t p, - std::shared_ptr previous, T* output, ParallelMergeFuture* future) { const uint64_t output_end = std::min(total_items, (p + 1) * target_unit_size); auto accumulated_stream_bounds = - identify_merge_unit(streams, cmp, output_end); - - future->merge_bounds_.push_back(output_end); - - if (previous) { - MergeUnit unit; - unit.starts = previous->ends; - unit.ends = accumulated_stream_bounds->ends; + identify_merge_unit(streams, cmp, future->control_memory(), output_end); + if (p == 0) { + future->merge_bounds_[p] = accumulated_stream_bounds; auto unit_future = pool->execute( - tournament_merge, - streams, - cmp, - std::make_shared(std::move(unit)), - output); - future->merge_units_.push(std::move(unit_future)); + tournament_merge, streams, cmp, future->merge_bounds_[p], output); + future->merge_tasks_.push(std::move(unit_future)); } else { + future->merge_bounds_[p].starts = future->merge_bounds_[p - 1].ends; + future->merge_bounds_[p].ends = accumulated_stream_bounds.ends; + auto unit_future = pool->execute( - tournament_merge, streams, cmp, accumulated_stream_bounds, output); - future->merge_units_.push(std::move(unit_future)); + tournament_merge, streams, cmp, future->merge_bounds_[p], output); + future->merge_tasks_.push(std::move(unit_future)); } if (p < parallel_factor - 1) { @@ -407,11 +455,10 @@ class ParallelMerge { total_items, target_unit_size, p + 1, - accumulated_stream_bounds, output, future); } else { - future->merge_units_.drain(); + future->merge_tasks_.drain(); } return tiledb::common::Status::Ok(); @@ -419,21 +466,12 @@ class ParallelMerge { static void spawn_merge_units( tiledb::common::ThreadPool& pool, - const ParallelMergeOptions& options, + size_t parallel_factor, + uint64_t total_items, Streams streams, Compare& cmp, T* output, ParallelMergeFuture& future) { - uint64_t total_items = 0; - for (const auto& stream : streams) { - total_items += stream.size(); - } - - const uint64_t parallel_factor = std::clamp( - total_items / options.min_merge_items, - static_cast(1), - options.parallel_factor); - // NB: round up, if there is a shorter merge unit it will be the last one. const uint64_t target_unit_size = (total_items + (parallel_factor - 1)) / parallel_factor; @@ -447,7 +485,6 @@ class ParallelMerge { total_items, target_unit_size, static_cast(0), - std::shared_ptr(nullptr), output, &future); } @@ -458,27 +495,42 @@ class ParallelMerge { friend struct VerifyTournamentMerge; public: - static std::unique_ptr start( + static tdb::pmr::unique_ptr start( tiledb::common::ThreadPool& pool, + ParallelMergeMemoryResources& memory, const ParallelMergeOptions& options, Streams streams, Compare& cmp, T* output) { - std::unique_ptr future(new ParallelMergeFuture()); + uint64_t total_items = 0; + for (const auto& stream : streams) { + total_items += stream.size(); + } + + const uint64_t parallel_factor = std::clamp( + total_items / options.min_merge_items, + static_cast(1), + options.parallel_factor); + + tdb::pmr::unique_ptr future = + tdb::pmr::emplace_unique( + &memory.control, memory, parallel_factor); ParallelMerge::spawn_merge_units( - pool, options, streams, cmp, output, *future); + pool, parallel_factor, total_items, streams, cmp, output, *future); return future; } }; template -std::unique_ptr parallel_merge( +tdb::pmr::unique_ptr parallel_merge( tiledb::common::ThreadPool& pool, + ParallelMergeMemoryResources& memory, const ParallelMergeOptions& options, std::span> streams, Compare& cmp, T* output) { - return ParallelMerge::start(pool, options, streams, cmp, output); + return ParallelMerge::start( + pool, memory, options, streams, cmp, output); } } // namespace tiledb::algorithm diff --git a/tiledb/common/algorithm/test/CMakeLists.txt b/tiledb/common/algorithm/test/CMakeLists.txt index c3e5e291479..9ba9b921f41 100644 --- a/tiledb/common/algorithm/test/CMakeLists.txt +++ b/tiledb/common/algorithm/test/CMakeLists.txt @@ -29,5 +29,6 @@ include(unit_test) commence(unit_test algorithm) this_target_object_libraries(algorithm) this_target_sources(main.cc unit_parallel_merge.cc) + this_target_link_libraries(tiledb_test_support_lib) this_target_link_libraries(${LIBRAPIDCHECK}) conclude(unit_test) diff --git a/tiledb/common/algorithm/test/unit_parallel_merge.cc b/tiledb/common/algorithm/test/unit_parallel_merge.cc index 183a2983169..69a392e8d29 100644 --- a/tiledb/common/algorithm/test/unit_parallel_merge.cc +++ b/tiledb/common/algorithm/test/unit_parallel_merge.cc @@ -30,11 +30,14 @@ #include "tiledb/common/algorithm/parallel_merge.h" +#include #include #include using namespace tiledb::algorithm; using namespace tiledb::common; +using namespace tiledb::sm; +using namespace tiledb::test; namespace tiledb::algorithm { @@ -50,6 +53,8 @@ using Streams = std::vector>; */ template struct VerifySplitPointStream { + std::shared_ptr memory; + Streams streams; uint64_t which; MergeUnit search_bounds; @@ -67,7 +72,11 @@ struct VerifySplitPointStream { auto cmp = std::less{}; auto result = ParallelMerge::split_point_stream_bounds( - spans, cmp, which, search_bounds); + spans, + cmp, + *memory->get_resource(MemoryType::PARALLEL_MERGE_CONTROL), + which, + search_bounds); RC_ASSERT(result.ends[which] > 0); @@ -95,35 +104,39 @@ struct VerifyIdentifyMergeUnit { spans.push_back(std::span(stream)); } + auto memory_tracker = get_test_memory_tracker(); + auto& memory = + *memory_tracker->get_resource(MemoryType::PARALLEL_MERGE_CONTROL); + auto cmp = std::less{}; - auto result = - ParallelMerge::identify_merge_unit(spans, &cmp, target_items); - RC_ASSERT(target_items == result->num_items()); + auto result = ParallelMerge::identify_merge_unit( + spans, &cmp, memory, target_items); + RC_ASSERT(target_items == result.num_items()); for (size_t s = 0; s < streams.size(); s++) { if (streams[s].empty()) { - RC_ASSERT(result->starts[s] == 0); - RC_ASSERT(result->ends[s] == 0); - } else if (result->starts[s] == result->ends[s]) { + RC_ASSERT(result.starts[s] == 0); + RC_ASSERT(result.ends[s] == 0); + } else if (result.starts[s] == result.ends[s]) { // this stream is not used at all, its first item must exceed // what lies at the boundary for all other streams for (size_t s2 = 0; s2 < streams.size(); s2++) { - if (result->starts[s2] != result->ends[s2]) { - RC_ASSERT(streams[s][0] >= streams[s2][result->ends[s2] - 1]); + if (result.starts[s2] != result.ends[s2]) { + RC_ASSERT(streams[s][0] >= streams[s2][result.ends[s2] - 1]); } } } else { // items from this stream in range `[starts[s], ends[s])` are included // in the merge unit, so everything outside of the merge unit must // exceed it - auto& bound_item = streams[s][result->ends[s] - 1]; + auto& bound_item = streams[s][result.ends[s] - 1]; for (size_t s2 = 0; s2 < streams.size(); s2++) { - if (result->ends[s2] == streams[s2].size()) { + if (result.ends[s2] == streams[s2].size()) { // the entirety of `s2` is included in the merge unit, // we can infer no relation to `bound_item` continue; } else { - RC_ASSERT(bound_item <= streams[s2][result->ends[s2]]); + RC_ASSERT(bound_item <= streams[s2][result.ends[s2]]); } } } @@ -133,16 +146,19 @@ struct VerifyIdentifyMergeUnit { template struct VerifyTournamentMerge { + std::shared_ptr memory_tracker; + // appears unused but is needed for `MergeUnit` lifetime + Streams streams; - std::shared_ptr unit; + MergeUnit unit; void verify() { auto cmp = std::less{}; - std::vector output(unit->num_items()); + std::vector output(unit.num_items()); - // SAFETY: the merge unit will begin writing at index `unit->output_start()` - T* output_ptr = &output[-unit->output_start()]; + // SAFETY: the merge unit will begin writing at index `unit.output_start()` + T* output_ptr = &output[-unit.output_start()]; std::vector> spans; for (size_t s = 0; s < streams.size(); s++) { @@ -160,8 +176,8 @@ struct VerifyTournamentMerge { for (size_t s = 0; s < streams.size(); s++) { inputcmp.insert( inputcmp.end(), - streams[s].begin() + unit->starts[s], - streams[s].begin() + unit->ends[s]); + streams[s].begin() + unit.starts[s], + streams[s].begin() + unit.ends[s]); } std::sort(inputcmp.begin(), inputcmp.end()); @@ -200,9 +216,12 @@ struct VerifyParallelMerge { std::vector output(total_items); + auto memory_tracker = get_test_memory_tracker(); + ParallelMergeMemoryResources resources(*memory_tracker.get()); + ThreadPool pool(pool_concurrency); - auto future = - parallel_merge(pool, options, spans, cmp, &output[0]); + auto future = parallel_merge( + pool, resources, options, spans, cmp, &output[0]); std::optional prev_bound; std::optional bound; @@ -257,7 +276,8 @@ Gen> streams_non_empty() { } template -Gen merge_unit(const Streams& streams) { +Gen merge_unit( + std::shared_ptr memory_tracker, const Streams& streams) { std::vector>> all_stream_bounds; for (const auto& stream : streams) { Gen> bounds = gen::apply( @@ -279,9 +299,13 @@ Gen merge_unit(const Streams& streams) { return bounds; }); + auto memory = + memory_tracker->get_resource(MemoryType::PARALLEL_MERGE_CONTROL); + return gen::map( - gen_stream_bounds, [](std::vector> bounds) { - MergeUnit unit; + gen_stream_bounds, + [memory](std::vector> bounds) { + MergeUnit unit(*memory); unit.starts.reserve(bounds.size()); unit.ends.reserve(bounds.size()); for (const auto& bound : bounds) { @@ -327,11 +351,16 @@ struct Arbitrary> { } } + auto memory_tracker = get_test_memory_tracker(); + auto which = gen::elementOf(which_candidates); - auto search_bounds = merge_unit(streams); + auto search_bounds = merge_unit(memory_tracker, streams); return gen::apply( - [](Streams streams, uint64_t which, MergeUnit search_bounds) { + [](std::shared_ptr memory_tracker, + Streams streams, + uint64_t which, + MergeUnit search_bounds) { for (size_t s = 0; s < streams.size(); s++) { if (s == which && search_bounds.starts[s] == search_bounds.ends[s]) { @@ -344,10 +373,12 @@ struct Arbitrary> { } } return VerifySplitPointStream{ + .memory = memory_tracker, .streams = streams, .which = which, .search_bounds = search_bounds}; }, + gen::just(memory_tracker), gen::just(streams), which, search_bounds); @@ -378,11 +409,14 @@ template struct Arbitrary> { static Gen> arbitrary() { return gen::mapcat(streams(), [](Streams streams) { - auto unit = merge_unit(streams); + auto memory_tracker = get_test_memory_tracker(); + auto unit = merge_unit(memory_tracker, streams); return gen::apply( - [](Streams streams, MergeUnit unit) { - return VerifyTournamentMerge{ - .streams = streams, .unit = std::make_shared(unit)}; + [memory_tracker](Streams streams, MergeUnit unit) { + return VerifyTournamentMerge{ + .memory_tracker = memory_tracker, + .streams = streams, + .unit = unit}; }, gen::just(streams), unit); @@ -427,11 +461,11 @@ void show>( show(instance.streams, os); os << "," << std::endl; os << "\t\"starts\": ["; - show(instance.unit->starts, os); + show(instance.unit.starts, os); os << "]" << std::endl; os << "," << std::endl; os << "\t\"ends\": ["; - show(instance.unit->ends, os); + show(instance.unit.ends, os); os << "]" << std::endl; os << "}"; } @@ -576,6 +610,9 @@ TEST_CASE("parallel merge example", "[algorithm][parallel_merge]") { ParallelMergeOptions options = {.parallel_factor = 4, .min_merge_items = 4}; + auto memory_tracker = get_test_memory_tracker(); + ParallelMergeMemoryResources resources(*memory_tracker.get()); + ThreadPool pool(4); SECTION("less") { @@ -596,9 +633,8 @@ TEST_CASE("parallel merge example", "[algorithm][parallel_merge]") { std::span(streambufs[3]), }; - std::unique_ptr future = - parallel_merge( - pool, options, streams, cmp, &output[0]); + auto future = parallel_merge( + pool, resources, options, streams, cmp, &output[0]); future->block(); @@ -624,9 +660,8 @@ TEST_CASE("parallel merge example", "[algorithm][parallel_merge]") { std::span(streambufs[3]), }; - std::unique_ptr future = - parallel_merge( - pool, options, streams, cmp, &output[0]); + auto future = parallel_merge( + pool, resources, options, streams, cmp, &output[0]); future->block(); diff --git a/tiledb/common/memory_tracker.cc b/tiledb/common/memory_tracker.cc index 47601320d91..787bd64f773 100644 --- a/tiledb/common/memory_tracker.cc +++ b/tiledb/common/memory_tracker.cc @@ -76,6 +76,8 @@ std::string memory_type_to_str(MemoryType type) { return "GenericTileIO"; case MemoryType::METADATA: return "Metadata"; + case MemoryType::PARALLEL_MERGE_CONTROL: + return "ParallelMergeControl"; case MemoryType::QUERY_CONDITION: return "QueryCondition"; case MemoryType::RESULT_TILE: diff --git a/tiledb/common/memory_tracker.h b/tiledb/common/memory_tracker.h index 67afebf5a81..e56ec902b11 100644 --- a/tiledb/common/memory_tracker.h +++ b/tiledb/common/memory_tracker.h @@ -122,6 +122,7 @@ enum class MemoryType { GENERIC_TILE_IO, METADATA, QUERY_CONDITION, + PARALLEL_MERGE_CONTROL, RESULT_TILE, RESULT_TILE_BITMAP, RTREE, diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 26ee0c598cc..7236b5186be 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -433,17 +433,17 @@ void SparseGlobalOrderReader::compute_result_tile_order() { 128 // TODO: do some experiments to figure something out }; + algorithm::ParallelMergeMemoryResources merge_resources( + *query_memory_tracker_.get()); + auto do_global_order_merge = [&]() { GlobalOrderMBRCmp cmp( array_schema_.domain(), fragment_metadata_); auto merge_stream = algorithm::parallel_merge( resources_.compute_tp(), + merge_resources, merge_options, fragment_result_tile_spans, - /* - std::span( - fragment_result_tile_spans.begin(), - fragment_result_tile_spans.end()),*/ cmp, &merged_result_tiles[0]); From a2c6a8d26437c2b047e9db36c571afde1cccab59 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 10 Dec 2024 11:26:21 -0500 Subject: [PATCH 029/228] Test tweaks --- test/src/unit-sparse-global-order-reader.cc | 22 ++++++++++++++------- 1 file changed, 15 insertions(+), 7 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index a29529f6655..1804930bbd0 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -101,17 +101,24 @@ struct CSparseGlobalOrderFx { void reset_config(); void update_config(); - std::string error_if_any() const; + template + std::string error_if_any(CAPIReturn apirc) const; CSparseGlobalOrderFx(); ~CSparseGlobalOrderFx(); }; -std::string CSparseGlobalOrderFx::error_if_any() const { +template +std::string CSparseGlobalOrderFx::error_if_any(CAPIReturn apirc) const { + if (apirc == TILEDB_OK) { + return ""; + } + tiledb_error_t* error = NULL; auto rc = tiledb_ctx_get_last_error(ctx_, &error); REQUIRE(rc == TILEDB_OK); if (error == nullptr) { + // probably should be unreachable return ""; } @@ -811,7 +818,7 @@ TEST_CASE_METHOD( CHECK(rc == TILEDB_OK); rc = tiledb_query_submit(ctx_, query); - REQUIRE("" == error_if_any()); + REQUIRE("" == error_if_any(rc)); CHECK(outcoords_size == num_output_cells_per_iter * sizeof(int)); outcursor += num_output_cells_per_iter; @@ -931,7 +938,7 @@ TEST_CASE_METHOD( CHECK(rc == TILEDB_OK); rc = tiledb_query_submit(ctx_, query); - REQUIRE("" == error_if_any()); + REQUIRE("" == error_if_any(rc)); CHECK(outcoords_size == num_output_cells_per_iter * sizeof(int)); outcursor += num_output_cells_per_iter; @@ -1539,10 +1546,10 @@ TEST_CASE_METHOD( create_default_array_1d(); bool use_subarray = false; - SECTION("- No subarray") { + SECTION("No subarray") { use_subarray = false; } - SECTION("- Subarray") { + SECTION("Subarray") { use_subarray = true; } @@ -1602,8 +1609,9 @@ TEST_CASE_METHOD( CHECK(!std::memcmp(&loop_idx, data_r, data_r_size)); loop_idx++; - while (status == TILEDB_INCOMPLETE && rc == TILEDB_OK) { + while (status == TILEDB_INCOMPLETE) { rc = tiledb_query_submit(ctx_, query); + CHECK("" == error_if_any(rc)); tiledb_query_get_status(ctx_, query, &status); CHECK(4 == data_r_size); CHECK(4 == coords_r_size); From 9023c1c2375573f9eee1c4fede3d903dcfbb9887 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 10 Dec 2024 11:26:44 -0500 Subject: [PATCH 030/228] Relax condition for throwing 'Cannot load a single tile' --- .../readers/sparse_global_order_reader.cc | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 7236b5186be..9ae598fc49a 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -532,13 +532,25 @@ SparseGlobalOrderReader::create_result_tiles( f, t); - if (rt == result_tile_cursor_) { + bool canProgress = false; + for (const auto& rts : result_tiles) { + if (!rts.empty()) { + canProgress = true; + break; + } + } + + if (!canProgress) { // this means we cannot safely produce any results const auto tiles_size = get_coord_tiles_size(num_dims, f, t); throw SparseGlobalOrderReaderException( "Cannot load a single tile, increase memory budget: " - "next tile size = " + - std::to_string(tiles_size) + ", total_budget = " + + "current coords tile size = " + + std::to_string(memory_used_for_coords_total_) + + ", next coords tile size = " + std::to_string(tiles_size) + + ", coords tile budget = " + + std::to_string(memory_budget_.coordinates_budget()) + + ", total_budget = " + std::to_string(memory_budget_.total_budget())); } else { // this tile has the lowest MBR lower bound of the remaining tiles, From 83527f097d5e64aa0ded856f67358e0d2cc72b36 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 10 Dec 2024 12:01:09 -0500 Subject: [PATCH 031/228] emplace_unique is not a violation --- scripts/find_heap_api_violations.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/find_heap_api_violations.py b/scripts/find_heap_api_violations.py index 044dcad0446..12a232394c3 100755 --- a/scripts/find_heap_api_violations.py +++ b/scripts/find_heap_api_violations.py @@ -104,7 +104,7 @@ "zstd_compressor.h": ["std::unique_ptr ctx_;", "std::unique_ptr ctx_;"], "posix.cc": ["std::unique_ptr", "static std::unique_ptr cwd_(getcwd(nullptr, 0), free);"], "curl.h": ["std::unique_ptr"], - "pmr.h": ["std::unique_ptr", "unique_ptr make_unique("], + "pmr.h": ["std::unique_ptr", "unique_ptr make_unique(", "unique_ptr emplace_unique("], } From d3358027c75a398dc209703dc1d6c3f6cb583302 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 10 Dec 2024 14:17:41 -0500 Subject: [PATCH 032/228] Consolidate and refactor comparators --- tiledb/sm/misc/comparators.h | 160 +++++++++++------- .../readers/sparse_global_order_reader.cc | 67 +++++--- tiledb/sm/tile/comparators.h | 126 -------------- 3 files changed, 143 insertions(+), 210 deletions(-) delete mode 100644 tiledb/sm/tile/comparators.h diff --git a/tiledb/sm/misc/comparators.h b/tiledb/sm/misc/comparators.h index 5a67b2b7d16..f1348ac2a4f 100644 --- a/tiledb/sm/misc/comparators.h +++ b/tiledb/sm/misc/comparators.h @@ -49,6 +49,23 @@ using namespace tiledb::common; namespace tiledb::sm { +template +concept CellCmpable = + requires(const T& a, const Dimension& dim, unsigned dim_idx) { + { a.dimension_datum(dim, dim_idx) } -> std::same_as; + }; + +namespace cell_compare { +template +int compare( + const Domain& domain, unsigned int d, const RCTypeL& a, const RCTypeR& b) { + const auto& dim{*(domain.dimension_ptr(d))}; + auto v1{a.dimension_datum(dim, d)}; + auto v2{b.dimension_datum(dim, d)}; + return domain.cell_order_cmp(d, v1, v2); +} +} // namespace cell_compare + class CellCmpBase { protected: /** The domain. */ @@ -63,13 +80,10 @@ class CellCmpBase { , dim_num_(domain.dim_num()) { } - template + template [[nodiscard]] int cell_order_cmp_RC( unsigned int d, const RCTypeL& a, const RCTypeR& b) const { - const auto& dim{*(domain_.dimension_ptr(d))}; - auto v1{a.dimension_datum(dim, d)}; - auto v2{b.dimension_datum(dim, d)}; - return domain_.cell_order_cmp(d, v1, v2); + return cell_compare::compare(domain_, d, a, b); } }; @@ -330,13 +344,68 @@ class HilbertCmpRCI : protected CellCmpBase { */ template concept GlobalCellCmpable = - requires(const T& a, const Dimension& dim, unsigned d) { + CellCmpable and requires(const T& a, const Dimension& dim, unsigned d) { { a.coord(d) } -> std::convertible_to; - { a.dimension_datum(dim, d) } -> std::same_as; - { a.fragment_idx() } -> std::convertible_to; - { a.tile_idx() } -> std::convertible_to; }; +template +struct global_order_compare { + template + static int compare( + const Domain& domain, const GlobalCmpL& a, const GlobalCmpR& b) { + const auto num_dims = domain.dim_num(); + + for (unsigned di = 0; di < num_dims; ++di) { + const unsigned d = + (TILE_ORDER == Layout::ROW_MAJOR ? di : (num_dims - di - 1)); + + // Not applicable to var-sized dimensions + if (domain.dimension_ptr(d)->var_size()) + continue; + + auto res = domain.tile_order_cmp(d, a.coord(d), b.coord(d)); + if (res != 0) { + return res; + } + // else same tile on dimension d --> continue + } + + // then cell order + for (unsigned di = 0; di < num_dims; ++di) { + const unsigned d = + (CELL_ORDER == Layout::ROW_MAJOR ? di : (num_dims - di - 1)); + auto res = cell_compare::compare(domain, d, a, b); + + if (res != 0) { + return res; + } + // else same tile on dimension d --> continue + } + + // NB: some other comparators care about timestamps here, we will not bother + // (for now?) + return 0; + } +}; + +template +class GlobalCellCmpStaticDispatch : public CellCmpBase { + public: + explicit GlobalCellCmpStaticDispatch(const Domain& domain) + : CellCmpBase(domain) { + static_assert( + TILE_ORDER == Layout::ROW_MAJOR || TILE_ORDER == Layout::COL_MAJOR); + static_assert( + CELL_ORDER == Layout::ROW_MAJOR || CELL_ORDER == Layout::COL_MAJOR); + } + + template + bool operator()(const GlobalCmpL& a, const GlobalCmpR& b) const { + return global_order_compare::compare( + domain_, a, b) < 0; + } +}; + class GlobalCellCmp : public CellCmpBase { public: GlobalCellCmp(const Domain& domain) @@ -348,53 +417,22 @@ class GlobalCellCmp : public CellCmpBase { template int compare(const GlobalCmpL& a, const GlobalCmpR& b) const { if (tile_order_ == Layout::ROW_MAJOR) { - for (unsigned d = 0; d < dim_num_; ++d) { - // Not applicable to var-sized dimensions - if (domain_.dimension_ptr(d)->var_size()) - continue; - - auto res = domain_.tile_order_cmp(d, a.coord(d), b.coord(d)); - if (res != 0) { - return res; - } - // else same tile on dimension d --> continue - } - } else { // COL_MAJOR - assert(tile_order_ == Layout::COL_MAJOR); - for (int32_t d = static_cast(dim_num_) - 1; d >= 0; d--) { - // Not applicable to var-sized dimensions - if (domain_.dimension_ptr(d)->var_size()) - continue; - - auto res = domain_.tile_order_cmp(d, a.coord(d), b.coord(d)); - if (res != 0) { - return res; - } - // else same tile on dimension d --> continue - } - } - - // Compare cell order - if (cell_order_ == Layout::ROW_MAJOR) { - for (unsigned d = 0; d < dim_num_; ++d) { - auto res = cell_order_cmp_RC(d, a, b); - if (res != 0) { - return res; - } - // else same tile on dimension d --> continue + if (cell_order_ == Layout::ROW_MAJOR) { + return global_order_compare:: + compare(domain_, a, b); + } else { + return global_order_compare:: + compare(domain_, a, b); } - } else { // COL_MAJOR - assert(cell_order_ == Layout::COL_MAJOR); - for (int32_t d = static_cast(dim_num_) - 1; d >= 0; d--) { - auto res = cell_order_cmp_RC(d, a, b); - if (res != 0) { - return res; - } - // else same tile on dimension d --> continue + } else { + if (cell_order_ == Layout::ROW_MAJOR) { + return global_order_compare:: + compare(domain_, a, b); + } else { + return global_order_compare:: + compare(domain_, a, b); } } - - return 0; } template @@ -409,6 +447,14 @@ class GlobalCellCmp : public CellCmpBase { Layout cell_order_; }; +template +concept GlobalTileCmpable = + GlobalCellCmpable and requires(const T& a, uint64_t pos) { + { a.fragment_idx() } -> std::convertible_to; + { a.tile_idx() } -> std::convertible_to; + { a.tile_->timestamp(pos) } -> std::same_as; + }; + /** * Wrapper of comparison function for sorting coords on the global order * of some domain. @@ -434,13 +480,13 @@ class GlobalCmp : public ResultTileCmpBase { } /** - * Comparison operator for a vector of `GlobalCellCmpable`. + * Comparison operator for a vector of `GlobalTileCmpable`. * * @param a The first coordinate. * @param b The second coordinate. * @return `true` if `a` precedes `b` and `false` otherwise. */ - template + template bool operator()(const GlobalCmpL& a, const GlobalCmpR& b) const { const int cellcmp = cellcmp_.compare(a, b); if (cellcmp < 0) { @@ -501,8 +547,8 @@ class GlobalCmpReverse { * @param b The second coordinate. * @return `true` if `a` precedes `b` and `false` otherwise. */ - template - bool operator()(const RCType& a, const RCType& b) const { + template + bool operator()(const GlobalCmpL& a, const GlobalCmpR& b) const { return !cmp_.operator()(a, b); } diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 9ae598fc49a..ef3f211c7ac 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -47,7 +47,6 @@ #include "tiledb/sm/query/readers/result_tile.h" #include "tiledb/sm/stats/global_stats.h" #include "tiledb/sm/subarray/subarray.h" -#include "tiledb/sm/tile/comparators.h" using namespace tiledb; using namespace tiledb::common; @@ -62,6 +61,21 @@ class SparseGlobalOrderReaderException : public StatusException { } }; +/** + * View into NDRange for using the range start / lower bound in comparisons. + */ +struct RangeLowerBound { + const NDRange& mbr; + + const void* coord(unsigned dim) const { + return mbr[dim].data(); + } + + UntypedDatumView dimension_datum(const Dimension&, unsigned dim) const { + return mbr[dim].start_datum(); + } +}; + /* ****************************** */ /* CONSTRUCTORS */ /* ****************************** */ @@ -437,8 +451,30 @@ void SparseGlobalOrderReader::compute_result_tile_order() { *query_memory_tracker_.get()); auto do_global_order_merge = [&]() { - GlobalOrderMBRCmp cmp( - array_schema_.domain(), fragment_metadata_); + struct ResultTileCmp { + using PerFragmentMetadata = + const std::vector>; + + ResultTileCmp( + const Domain& domain, const PerFragmentMetadata& fragment_metadata) + : cmp_(domain) + , fragment_metadata_(fragment_metadata) { + } + + bool operator()(const ResultTileId& a, const ResultTileId& b) const { + const RangeLowerBound a_mbr = { + .mbr = fragment_metadata_[a.fragment_idx_]->mbr(a.tile_idx_)}; + const RangeLowerBound b_mbr = { + .mbr = fragment_metadata_[b.fragment_idx_]->mbr(b.tile_idx_)}; + return cmp_(a_mbr, b_mbr); + } + + GlobalCellCmpStaticDispatch cmp_; + const PerFragmentMetadata& fragment_metadata_; + }; + + ResultTileCmp cmp(array_schema_.domain(), fragment_metadata_); + auto merge_stream = algorithm::parallel_merge( resources_.compute_tp(), merge_resources, @@ -942,30 +978,7 @@ bool SparseGlobalOrderReader::add_next_cell_to_queue( // Skip comparison if the next one is the same fragment, // in that case we know the cells are ordered correctly if (frag_idx != next_global_order_tile.fragment_idx_) { - struct FutureResultTileLowerBound { - const ResultTileId& tile; - const NDRange& mbr; - - const void* coord(unsigned dim) const { - return mbr[dim].data(); - } - - UntypedDatumView dimension_datum( - const Dimension&, unsigned dim) const { - return mbr[dim].start_datum(); - } - - unsigned fragment_idx() const { - return tile.fragment_idx_; - } - - uint64_t tile_idx() const { - return tile.tile_idx_; - } - }; - - FutureResultTileLowerBound target = { - .tile = next_global_order_tile, .mbr = emit_bound}; + RangeLowerBound target = {.mbr = emit_bound}; GlobalCellCmp cmp(array_schema_.domain()); diff --git a/tiledb/sm/tile/comparators.h b/tiledb/sm/tile/comparators.h deleted file mode 100644 index 9607fc344cf..00000000000 --- a/tiledb/sm/tile/comparators.h +++ /dev/null @@ -1,126 +0,0 @@ -/** - * @file comparators.h - * - * @section LICENSE - * - * The MIT License - * - * @copyright Copyright (c) 2017-2024 TileDB, Inc. - * @copyright Copyright (c) 2016 MIT and Intel Corporation - * - * 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. - * - * @section DESCRIPTION - * - * Defines custom comparators to be used for arranging tiles according to - * their MBR (minimum bounding rectangle) found in fragment metadata. - */ - -#ifndef TILEDB_TILE_COMPARATORS_H -#define TILEDB_TILE_COMPARATORS_H - -#include "tiledb/sm/misc/comparators.h" -#include "tiledb/sm/query/readers/result_tile.h" - -namespace tiledb::sm { - -int cell_order_cmp_NDRange( - const Domain& domain, unsigned int d, const NDRange& a, const NDRange& b) { - const auto& dim = *domain.dimension_ptr(d); - if (dim.var_size()) { - UntypedDatumView v1(a[d].start_str().data(), a[d].start_str().size()); - UntypedDatumView v2(b[d].start_str().data(), a[d].start_str().size()); - return domain.cell_order_cmp(d, v1, v2); - } else { - UntypedDatumView v1(a[d].start_fixed(), a[d].start_size()); - UntypedDatumView v2(b[d].start_fixed(), a[d].start_size()); - return domain.cell_order_cmp(d, v1, v2); - } -} - -template -class GlobalOrderMBRCmp { - public: - explicit GlobalOrderMBRCmp( - const Domain& domain, - const std::vector>& fragment_metadata) - : domain_(domain) - , fragment_metadata_(fragment_metadata) { - static_assert( - TILE_ORDER == Layout::ROW_MAJOR || TILE_ORDER == Layout::COL_MAJOR); - static_assert( - CELL_ORDER == Layout::ROW_MAJOR || CELL_ORDER == Layout::COL_MAJOR); - } - - bool operator()(const NDRange& left_mbr, const NDRange& right_mbr) const { - for (unsigned di = 0; di < domain_.dim_num(); ++di) { - const unsigned d = - (TILE_ORDER == Layout::ROW_MAJOR ? di : (domain_.dim_num() - di - 1)); - - // Not applicable to var-sized dimensions - if (domain_.dimension_ptr(d)->var_size()) - continue; - - auto res = - domain_.tile_order_cmp(d, left_mbr[d].data(), right_mbr[d].data()); - if (res < 0) { - return true; - } else if (res > 0) { - return false; - } - // else same tile on dimension d --> continue - } - - // then cell order - for (unsigned di = 0; di < domain_.dim_num(); ++di) { - const unsigned d = - (CELL_ORDER == Layout::ROW_MAJOR ? di : (domain_.dim_num() - di - 1)); - auto res = cell_order_cmp_NDRange(domain_, d, left_mbr, right_mbr); - - if (res < 0) { - return true; - } else if (res > 0) { - return false; - } - // else same tile on dimension d --> continue - } - - // NB: some other comparators care about timestamps here, we will not bother - // (for now?) - return 0; - } - - bool operator()(const ResultTileId& left, const ResultTileId& right) const { - const auto& left_mbr = - fragment_metadata_[left.fragment_idx_]->mbr(left.tile_idx_); - const auto& right_mbr = - fragment_metadata_[right.fragment_idx_]->mbr(right.tile_idx_); - - return (*this)(left_mbr, right_mbr); - } - - private: - const Domain& domain_; - - const std::vector>& fragment_metadata_; -}; - -} // namespace tiledb::sm - -#endif From c7e2ebbe6573beac938fc748241cba70be0b411a Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 10 Dec 2024 14:17:54 -0500 Subject: [PATCH 033/228] Avoid repeat constant in fragment skew test --- test/src/unit-sparse-global-order-reader.cc | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 1804930bbd0..03ada3e5d7b 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -752,20 +752,20 @@ TEST_CASE_METHOD( create_default_array_1d(true); // Write a fragment F0 with unique coordinates - std::vector f0coords(200); + std::vector f0coords(16); std::iota(f0coords.begin(), f0coords.end(), 1); uint64_t f0coords_size = f0coords.size() * sizeof(int); // Write a fragment F1 with lots of duplicates // [100,100,100,100,100,101,101,101,101,101,102,102,102,102,102,...] - std::vector f1coords(200); + std::vector f1coords(f0coords.size()); for (size_t i = 0; i < f1coords.size(); i++) { - f1coords[i] = static_cast(i / 10) + 100; + f1coords[i] = static_cast(i / 10) + (f0coords.size() / 2); } uint64_t f1coords_size = f1coords.size() * sizeof(int); - std::vector att(200); - std::iota(att.begin(), att.end(), 200); + std::vector att(f0coords.size()); + std::iota(att.begin(), att.end(), f0coords.size()); uint64_t att_size = att.size() * sizeof(int); write_1d_fragment(f0coords.data(), &f0coords_size, att.data(), &att_size); @@ -785,8 +785,8 @@ TEST_CASE_METHOD( ratio_array_data_ = "0.5"; update_config(); - std::vector outcoords(400); - std::vector outatt(400); + std::vector outcoords(f0coords.size() + f1coords.size()); + std::vector outatt(outcoords.size()); // Open array for reading. tiledb_array_t* array; From 477e72a7abdbdb8efff046abc17473e0e82ea3cf Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 11 Dec 2024 07:42:53 -0500 Subject: [PATCH 034/228] CSparseGlobalOrderFx::run_1d, used for fragment skew test --- test/src/unit-sparse-global-order-reader.cc | 276 +++++++++++++------- 1 file changed, 185 insertions(+), 91 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 03ada3e5d7b..8e675c7e10b 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -53,6 +53,23 @@ using namespace tiledb::test; /* STRUCT DEFINITION */ /* ********************************* */ +/** + * Contains the data for a single fragment + * of the 1D array created by `CSparseGlobalOrderFx` + */ +struct FxFragment1D { + std::vector coords; + std::vector atts; +}; + +/** + * An instance of input to `CSparseGlobalOrderFx::run_1d` + */ +struct FxRun1D { + uint64_t num_user_cells; + std::vector fragments; +}; + struct CSparseGlobalOrderFx { tiledb_ctx_t* ctx_ = nullptr; tiledb_vfs_t* vfs_ = nullptr; @@ -101,6 +118,13 @@ struct CSparseGlobalOrderFx { void reset_config(); void update_config(); + /** + * Runs an input against a fresh 1D array. + * Inserts fragments one at a time, then reads them back in global order + * and checks that what we read out matches what we put in. + */ + void run_1d(FxRun1D instance); + template std::string error_if_any(CAPIReturn apirc) const; @@ -277,11 +301,11 @@ void CSparseGlobalOrderFx::write_1d_fragment( // Submit query. rc = tiledb_query_submit(ctx_, query); - REQUIRE(rc == TILEDB_OK); + REQUIRE("" == error_if_any(rc)); // Close array. rc = tiledb_array_close(ctx_, array); - REQUIRE(rc == TILEDB_OK); + REQUIRE("" == error_if_any(rc)); // Clean up. tiledb_array_free(&array); @@ -746,103 +770,33 @@ TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: fragment skew", "[sparse-global-order]") { - reset_config(); - - // the tile extent is 2 - create_default_array_1d(true); - // Write a fragment F0 with unique coordinates - std::vector f0coords(16); - std::iota(f0coords.begin(), f0coords.end(), 1); - uint64_t f0coords_size = f0coords.size() * sizeof(int); + struct FxFragment1D fragment0; + fragment0.coords.resize(16); + std::iota(fragment0.coords.begin(), fragment0.coords.end(), 1); // Write a fragment F1 with lots of duplicates // [100,100,100,100,100,101,101,101,101,101,102,102,102,102,102,...] - std::vector f1coords(f0coords.size()); - for (size_t i = 0; i < f1coords.size(); i++) { - f1coords[i] = static_cast(i / 10) + (f0coords.size() / 2); - } - uint64_t f1coords_size = f1coords.size() * sizeof(int); - - std::vector att(f0coords.size()); - std::iota(att.begin(), att.end(), f0coords.size()); - uint64_t att_size = att.size() * sizeof(int); - - write_1d_fragment(f0coords.data(), &f0coords_size, att.data(), &att_size); - REQUIRE(f0coords_size == f0coords.size() * sizeof(int)); - REQUIRE(att_size == att.size() * sizeof(int)); - - write_1d_fragment(f1coords.data(), &f1coords_size, att.data(), &att_size); - REQUIRE(f1coords_size == f1coords.size() * sizeof(int)); - REQUIRE(att_size == att.size() * sizeof(int)); - - /** - * Now we should have 200 tiles, each of which has 2 coordinates, - * and each of which is size is 1584. - * In global order we skew towards fragment 1 which has lots of duplicates. - */ - total_budget_ = "20000"; - ratio_array_data_ = "0.5"; - update_config(); - - std::vector outcoords(f0coords.size() + f1coords.size()); - std::vector outatt(outcoords.size()); - - // Open array for reading. - tiledb_array_t* array; - auto rc = tiledb_array_alloc(ctx_, array_name_.c_str(), &array); - CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx_, array, TILEDB_READ); - CHECK(rc == TILEDB_OK); - - // Create query - tiledb_query_t* query; - rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); - CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); - CHECK(rc == TILEDB_OK); - - constexpr size_t num_output_cells_per_iter = 8; - - uint64_t outcursor = 0; - while (true) { - uint64_t outcoords_size; - uint64_t outatt_size; - outcoords_size = outatt_size = num_output_cells_per_iter * sizeof(int); - - rc = tiledb_query_set_data_buffer( - ctx_, query, "a", &outatt[outcursor], &outatt_size); - CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_data_buffer( - ctx_, query, "d", &outcoords[outcursor], &outcoords_size); - CHECK(rc == TILEDB_OK); - - rc = tiledb_query_submit(ctx_, query); - REQUIRE("" == error_if_any(rc)); - - CHECK(outcoords_size == num_output_cells_per_iter * sizeof(int)); - outcursor += num_output_cells_per_iter; - - tiledb_query_status_t status; - rc = tiledb_query_get_status(ctx_, query, &status); - REQUIRE(rc == TILEDB_OK); - if (status == TILEDB_COMPLETED) { - break; - } + struct FxFragment1D fragment1; + fragment1.coords.resize(fragment0.coords.size()); + for (size_t i = 0; i < fragment1.coords.size(); i++) { + fragment1.coords[i] = + static_cast(i / 10) + (fragment0.coords.size() / 2); } - // Clean up. - rc = tiledb_array_close(ctx_, array); - CHECK(rc == TILEDB_OK); - tiledb_array_free(&array); - tiledb_query_free(&query); + // atts are whatever + fragment0.atts.resize(fragment0.coords.size()); + std::iota(fragment0.atts.begin(), fragment0.atts.end(), 0); + fragment1.atts.resize(fragment1.coords.size()); + std::iota( + fragment1.atts.begin(), fragment1.atts.end(), fragment0.coords.size()); - std::vector expectcoords; - expectcoords.insert(expectcoords.end(), f0coords.begin(), f0coords.end()); - expectcoords.insert(expectcoords.end(), f1coords.begin(), f1coords.end()); - std::sort(expectcoords.begin(), expectcoords.end()); + struct FxRun1D instance; + instance.fragments.push_back(fragment0); + instance.fragments.push_back(fragment1); + instance.num_user_cells = 8; - CHECK(expectcoords == outcoords); + run_1d(instance); } /** @@ -1818,3 +1772,143 @@ TEST_CASE_METHOD( tiledb_array_free(&array); tiledb_query_free(&query); } + +void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { + reset_config(); + + // the tile extent is 2 + create_default_array_1d(true); + + // write all fragments + for (auto& fragment : instance.fragments) { + uint64_t coords_size = sizeof(int) * fragment.coords.size(); + uint64_t atts_size = sizeof(int) * fragment.atts.size(); + + // precondition: fragment must have the same number of cells for each field + REQUIRE(coords_size == atts_size); + + write_1d_fragment( + fragment.coords.data(), &coords_size, fragment.atts.data(), &atts_size); + REQUIRE(coords_size == sizeof(int) * fragment.coords.size()); + REQUIRE(atts_size == sizeof(int) * fragment.atts.size()); + } + + std::vector expectcoords; + std::vector expectatts; + for (const auto& fragment : instance.fragments) { + expectcoords.reserve(expectcoords.size() + fragment.coords.size()); + expectatts.reserve(expectatts.size() + fragment.atts.size()); + + expectcoords.insert( + expectcoords.end(), fragment.coords.begin(), fragment.coords.end()); + expectatts.insert( + expectatts.end(), fragment.atts.begin(), fragment.atts.end()); + } + + // sort for naive comparison + { + std::vector idxs(expectcoords.size()); + std::iota(idxs.begin(), idxs.end(), 0); + + std::sort(idxs.begin(), idxs.end(), [&](int ia, int ib) -> bool { + return expectcoords[ia] < expectcoords[ib]; + }); + + std::vector sortatts; + sortatts.reserve(idxs.size()); + for (const auto i : idxs) { + sortatts.push_back(expectatts[i]); + } + REQUIRE(sortatts.size() == expectatts.size()); + expectatts = sortatts; + + std::sort(expectcoords.begin(), expectcoords.end()); + } + + // Open array for reading. + tiledb_array_t* array; + auto rc = tiledb_array_alloc(ctx_, array_name_.c_str(), &array); + CHECK(rc == TILEDB_OK); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); + CHECK(rc == TILEDB_OK); + + // Create query + tiledb_query_t* query; + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); + CHECK(rc == TILEDB_OK); + rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); + CHECK(rc == TILEDB_OK); + + // Prepare output buffer + std::vector outcoords; + std::vector outatts; + for (const auto& fragment : instance.fragments) { + outcoords.resize(outcoords.size() + fragment.coords.size(), 0); + outatts.resize(outatts.size() + fragment.atts.size(), 0); + } + + uint64_t outcursor = 0; + while (true) { + uint64_t outcoords_size; + uint64_t outatts_size; + outcoords_size = outatts_size = instance.num_user_cells * sizeof(int); + + rc = tiledb_query_set_data_buffer( + ctx_, query, "a", &outatts[outcursor], &outatts_size); + CHECK(rc == TILEDB_OK); + rc = tiledb_query_set_data_buffer( + ctx_, query, "d", &outcoords[outcursor], &outcoords_size); + CHECK(rc == TILEDB_OK); + + rc = tiledb_query_submit(ctx_, query); + REQUIRE("" == error_if_any(rc)); + + tiledb_query_status_t status; + rc = tiledb_query_get_status(ctx_, query, &status); + REQUIRE(rc == TILEDB_OK); + + if (outcoords_size < instance.num_user_cells * sizeof(int)) { + CHECK(status == TILEDB_COMPLETED); + } else { + CHECK(outcoords_size == instance.num_user_cells * sizeof(int)); + } + CHECK(outcoords_size % sizeof(int) == 0); + outcursor += outcoords_size / sizeof(int); + + // since they are the same data type + CHECK(outatts_size == outcoords_size); + + if (status == TILEDB_COMPLETED) { + break; + } + } + + // Clean up. + rc = tiledb_array_close(ctx_, array); + CHECK(rc == TILEDB_OK); + tiledb_array_free(&array); + tiledb_query_free(&query); + + CHECK(expectcoords == outcoords); + + // Checking attributes is more complicated because equal coords + // can manifest their attributes in any order. + // Identify the runs of equal coords and then compare using those + REQUIRE(expectatts.size() == outatts.size()); + int attcursor = 0; + int runlength = 1; + for (size_t i = 1; i < expectcoords.size(); i++) { + if (expectcoords[i] == expectcoords[i - 1]) { + runlength++; + } else { + std::set expectattsrun( + expectatts.begin() + attcursor, + expectatts.begin() + attcursor + runlength); + std::set outattsrun( + outatts.begin() + attcursor, outatts.begin() + attcursor + runlength); + CHECK(expectattsrun == outattsrun); + attcursor += runlength; + runlength = 1; + } + } +} From 89f401c69bcdc3e091d75396843d21342bdd17e7 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 11 Dec 2024 08:06:44 -0500 Subject: [PATCH 035/228] Add rapidcheck for fragment skew test --- test/CMakeLists.txt | 1 + test/src/unit-sparse-global-order-reader.cc | 72 ++++++++++++++------- 2 files changed, 49 insertions(+), 24 deletions(-) diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 87117729340..6976fc2a36e 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -233,6 +233,7 @@ target_link_libraries(tiledb_unit Catch2::Catch2 tiledb_test_support_lib configuration_definitions + ${LIBRAPIDCHECK} ) target_link_libraries(tiledb_unit PRIVATE $) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 8e675c7e10b..05e6bf84812 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -44,6 +44,7 @@ #endif #include +#include #include using namespace tiledb; @@ -240,6 +241,15 @@ void CSparseGlobalOrderFx::update_config() { void CSparseGlobalOrderFx::create_default_array_1d(bool allow_dups) { int domain[] = {1, 200}; int tile_extent = 2; + + tiledb_object_t type; + auto rc = tiledb_object_type(ctx_, array_name_.c_str(), &type); + REQUIRE(rc == TILEDB_OK); + if (type == TILEDB_ARRAY) { + rc = tiledb_array_delete(ctx_, array_name_.c_str()); + REQUIRE(rc == TILEDB_OK); + } + create_array( ctx_, array_name_, @@ -770,33 +780,47 @@ TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: fragment skew", "[sparse-global-order]") { - // Write a fragment F0 with unique coordinates - struct FxFragment1D fragment0; - fragment0.coords.resize(16); - std::iota(fragment0.coords.begin(), fragment0.coords.end(), 1); - - // Write a fragment F1 with lots of duplicates - // [100,100,100,100,100,101,101,101,101,101,102,102,102,102,102,...] - struct FxFragment1D fragment1; - fragment1.coords.resize(fragment0.coords.size()); - for (size_t i = 0; i < fragment1.coords.size(); i++) { - fragment1.coords[i] = - static_cast(i / 10) + (fragment0.coords.size() / 2); - } + auto doit = [this](size_t fragment_size, size_t num_user_cells) { + // Write a fragment F0 with unique coordinates + struct FxFragment1D fragment0; + fragment0.coords.resize(fragment_size); + std::iota(fragment0.coords.begin(), fragment0.coords.end(), 1); + + // Write a fragment F1 with lots of duplicates + // [100,100,100,100,100,101,101,101,101,101,102,102,102,102,102,...] + struct FxFragment1D fragment1; + fragment1.coords.resize(fragment0.coords.size()); + for (size_t i = 0; i < fragment1.coords.size(); i++) { + fragment1.coords[i] = + static_cast(i / 10) + (fragment0.coords.size() / 2); + } + + // atts are whatever + fragment0.atts.resize(fragment0.coords.size()); + std::iota(fragment0.atts.begin(), fragment0.atts.end(), 0); + fragment1.atts.resize(fragment1.coords.size()); + std::iota( + fragment1.atts.begin(), fragment1.atts.end(), fragment0.coords.size()); + + struct FxRun1D instance; + instance.fragments.push_back(fragment0); + instance.fragments.push_back(fragment1); + instance.num_user_cells = num_user_cells; - // atts are whatever - fragment0.atts.resize(fragment0.coords.size()); - std::iota(fragment0.atts.begin(), fragment0.atts.end(), 0); - fragment1.atts.resize(fragment1.coords.size()); - std::iota( - fragment1.atts.begin(), fragment1.atts.end(), fragment0.coords.size()); + run_1d(instance); + }; - struct FxRun1D instance; - instance.fragments.push_back(fragment0); - instance.fragments.push_back(fragment1); - instance.num_user_cells = 8; + SECTION("Example") { + doit(200, 8); + } - run_1d(instance); + SECTION("Rapidcheck") { + rc::prop("rapidcheck fragment skew", [doit]() { + const size_t fragment_size = *rc::gen::inRange(2, 200); + const size_t num_user_cells = *rc::gen::inRange(1, 1024); + doit(fragment_size, num_user_cells); + }); + } } /** From a3f22c9045b42321844fc765b0ca81a8f08ab7f4 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 11 Dec 2024 08:52:15 -0500 Subject: [PATCH 036/228] Add rapidcheck for fragment interleave test --- test/src/unit-sparse-global-order-reader.cc | 196 ++++++++------------ 1 file changed, 82 insertions(+), 114 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 05e6bf84812..1f5f0a27a15 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -63,12 +63,28 @@ struct FxFragment1D { std::vector atts; }; +struct MemoryBudget { + std::string total_budget_; + std::string ratio_tile_ranges_; + std::string ratio_array_data_; + std::string ratio_coords_; + + MemoryBudget() + : total_budget_("1048576") + , ratio_tile_ranges_("0.1") + , ratio_array_data_("0.1") + , ratio_coords_("0.5") { + } +}; + /** * An instance of input to `CSparseGlobalOrderFx::run_1d` */ struct FxRun1D { uint64_t num_user_cells; std::vector fragments; + + MemoryBudget memory; }; struct CSparseGlobalOrderFx { @@ -78,10 +94,8 @@ struct CSparseGlobalOrderFx { std::string array_name_; const char* ARRAY_NAME = "test_sparse_global_order"; tiledb_array_t* array_ = nullptr; - std::string total_budget_; - std::string ratio_tile_ranges_; - std::string ratio_array_data_; - std::string ratio_coords_; + + MemoryBudget memory_; void create_default_array_1d(bool allow_dups = false); void create_default_array_1d_strings(bool allow_dups = false); @@ -175,10 +189,7 @@ CSparseGlobalOrderFx::~CSparseGlobalOrderFx() { } void CSparseGlobalOrderFx::reset_config() { - total_budget_ = "1048576"; - ratio_tile_ranges_ = "0.1"; - ratio_array_data_ = "0.1"; - ratio_coords_ = "0.5"; + memory_ = MemoryBudget(); update_config(); } @@ -204,15 +215,17 @@ void CSparseGlobalOrderFx::update_config() { REQUIRE( tiledb_config_set( - config, "sm.mem.total_budget", total_budget_.c_str(), &error) == - TILEDB_OK); + config, + "sm.mem.total_budget", + memory_.total_budget_.c_str(), + &error) == TILEDB_OK); REQUIRE(error == nullptr); REQUIRE( tiledb_config_set( config, "sm.mem.reader.sparse_global_order.ratio_tile_ranges", - ratio_tile_ranges_.c_str(), + memory_.ratio_tile_ranges_.c_str(), &error) == TILEDB_OK); REQUIRE(error == nullptr); @@ -220,7 +233,7 @@ void CSparseGlobalOrderFx::update_config() { tiledb_config_set( config, "sm.mem.reader.sparse_global_order.ratio_array_data", - ratio_array_data_.c_str(), + memory_.ratio_array_data_.c_str(), &error) == TILEDB_OK); REQUIRE(error == nullptr); @@ -228,7 +241,7 @@ void CSparseGlobalOrderFx::update_config() { tiledb_config_set( config, "sm.mem.reader.sparse_global_order.ratio_coords", - ratio_coords_.c_str(), + memory_.ratio_coords_.c_str(), &error) == TILEDB_OK); REQUIRE(error == nullptr); @@ -569,8 +582,8 @@ TEST_CASE_METHOD( // We should have one tile range (size 16) which will be bigger than budget // (10). - total_budget_ = "1000"; - ratio_tile_ranges_ = "0.01"; + memory_.total_budget_ = "1000"; + memory_.ratio_tile_ranges_ = "0.01"; update_config(); // Try to read. @@ -622,7 +635,7 @@ TEST_CASE_METHOD( // Specific relationship for failure not known, but these values // will result in failure with data being written. - total_budget_ = "10000"; + memory_.total_budget_ = "10000"; // Failure here occurs with the value of 0.1 for ratio_tile_ranges_. update_config(); @@ -711,7 +724,7 @@ TEST_CASE_METHOD( // specific relationship for failure not known, but these values // will result in failure with data being written. - total_budget_ = "15000"; + memory_.total_budget_ = "15000"; // Failure here occurs with the value of 0.1 for ratio_tile_ranges_. update_config(); @@ -840,107 +853,59 @@ TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: fragment interleave", "[sparse-global-order]") { - reset_config(); + // NB: the tile extent is 2 + auto doit = [this](size_t fragment_size, size_t num_user_cells) { + struct FxFragment1D fragment0; + struct FxFragment1D fragment1; - // the tile extent is 2 - create_default_array_1d(true); + // Write a fragment F0 with tiles [1,3][3,5][5,7][7,9]... + fragment0.coords.resize(fragment_size); + fragment0.coords[0] = 1; + for (size_t i = 1; i < fragment0.coords.size(); i++) { + fragment0.coords[i] = 1 + 2 * ((i + 1) / 2); + } - // Write a fragment F0 with tiles - // [1,3][3,5][5,7][7,9]... - std::vector f0coords(180); - f0coords[0] = 1; - for (size_t i = 1; i < f0coords.size(); i++) { - f0coords[i] = 1 + 2 * ((i + 1) / 2); - } - uint64_t f0coords_size = f0coords.size() * sizeof(int); + // Write a fragment F1 with tiles [2,4][4,6][6,8][8,10]... + fragment1.coords.resize(fragment0.coords.size()); + for (size_t i = 0; i < fragment1.coords.size(); i++) { + fragment1.coords[i] = fragment0.coords[i] + 1; + } - // Write a fragment F1 with tiles - // [2,4][4,6][6,8][8,10]... - std::vector f1coords(f0coords.size()); - for (size_t i = 0; i < f1coords.size(); i++) { - f1coords[i] = f0coords[i] + 1; - } - uint64_t f1coords_size = f1coords.size() * sizeof(int); + // atts don't really matter + fragment0.atts.resize(fragment0.coords.size()); + std::iota(fragment0.atts.begin(), fragment0.atts.end(), 0); - std::vector att(f0coords.size()); - std::iota(att.begin(), att.end(), f0coords.size()); - uint64_t att_size = att.size() * sizeof(int); + fragment1.atts.resize(fragment1.coords.size()); + std::iota( + fragment1.atts.begin(), fragment1.atts.end(), fragment0.atts.size()); - write_1d_fragment(f0coords.data(), &f0coords_size, att.data(), &att_size); - REQUIRE(f0coords_size == f0coords.size() * sizeof(int)); - REQUIRE(att_size == att.size() * sizeof(int)); + struct FxRun1D instance; + instance.fragments.push_back(fragment0); + instance.fragments.push_back(fragment1); + instance.num_user_cells = num_user_cells; + instance.memory.total_budget_ = "20000"; + instance.memory.ratio_array_data_ = "0.5"; - write_1d_fragment(f1coords.data(), &f1coords_size, att.data(), &att_size); - REQUIRE(f1coords_size == f1coords.size() * sizeof(int)); - REQUIRE(att_size == att.size() * sizeof(int)); + run_1d(instance); + }; + + SECTION("Example") { + doit(196, 8); + } + + SECTION("Rapidcheck") { + rc::prop("rapidcheck fragment interleave", [doit]() { + const size_t fragment_size = *rc::gen::inRange(2, 196); + const size_t num_user_cells = *rc::gen::inRange(1, 1024); + doit(fragment_size, num_user_cells); + }); + } /** * Now we should have 200 tiles, each of which has 2 coordinates, * and each of which is size is 1584. * In global order we skew towards fragment 1 which has lots of duplicates. */ - total_budget_ = "20000"; - ratio_array_data_ = "0.5"; - update_config(); - - std::vector outcoords(f0coords.size() + f1coords.size()); - std::vector outatt(outcoords.size()); - - // Open array for reading. - tiledb_array_t* array; - auto rc = tiledb_array_alloc(ctx_, array_name_.c_str(), &array); - CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx_, array, TILEDB_READ); - CHECK(rc == TILEDB_OK); - - // Create query - tiledb_query_t* query; - rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); - CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); - CHECK(rc == TILEDB_OK); - - constexpr size_t num_output_cells_per_iter = 8; - - uint64_t outcursor = 0; - while (true) { - uint64_t outcoords_size; - uint64_t outatt_size; - outcoords_size = outatt_size = num_output_cells_per_iter * sizeof(int); - - rc = tiledb_query_set_data_buffer( - ctx_, query, "a", &outatt[outcursor], &outatt_size); - CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_data_buffer( - ctx_, query, "d", &outcoords[outcursor], &outcoords_size); - CHECK(rc == TILEDB_OK); - - rc = tiledb_query_submit(ctx_, query); - REQUIRE("" == error_if_any(rc)); - - CHECK(outcoords_size == num_output_cells_per_iter * sizeof(int)); - outcursor += num_output_cells_per_iter; - - tiledb_query_status_t status; - rc = tiledb_query_get_status(ctx_, query, &status); - REQUIRE(rc == TILEDB_OK); - if (status == TILEDB_COMPLETED) { - break; - } - } - - // Clean up. - rc = tiledb_array_close(ctx_, array); - CHECK(rc == TILEDB_OK); - tiledb_array_free(&array); - tiledb_query_free(&query); - - std::vector expectcoords; - expectcoords.insert(expectcoords.end(), f0coords.begin(), f0coords.end()); - expectcoords.insert(expectcoords.end(), f1coords.begin(), f1coords.end()); - std::sort(expectcoords.begin(), expectcoords.end()); - - CHECK(expectcoords == outcoords); } TEST_CASE_METHOD( @@ -964,8 +929,8 @@ TEST_CASE_METHOD( // We should have 100 tiles (tile offset size 800) which will be bigger than // leftover budget. - total_budget_ = "3000"; - ratio_array_data_ = "0.5"; + memory_.total_budget_ = "3000"; + memory_.ratio_array_data_ = "0.5"; update_config(); // Try to read. @@ -1030,8 +995,8 @@ TEST_CASE_METHOD( // FIXME: there is no per fragment budget anymore // Two result tile (2 * (~3000 + 8) will be bigger than the per fragment // budget (1000). - total_budget_ = "35000"; - ratio_coords_ = "0.11"; + memory_.total_budget_ = "35000"; + memory_.ratio_coords_ = "0.11"; update_config(); tiledb_array_t* array = nullptr; @@ -1109,8 +1074,8 @@ TEST_CASE_METHOD( write_1d_fragment(coords, &coords_size, data, &data_size); // One result tile (8 + ~440) will be bigger than the budget (400). - total_budget_ = "19000"; - ratio_coords_ = "0.04"; + memory_.total_budget_ = "19000"; + memory_.ratio_coords_ = "0.04"; update_config(); // Try to read. @@ -1554,8 +1519,8 @@ TEST_CASE_METHOD( // FIXME: there is no per fragment budget anymore // Two result tile (2 * (~4000 + 8) will be bigger than the per fragment // budget (1000). - total_budget_ = "40000"; - ratio_coords_ = "0.22"; + memory_.total_budget_ = "40000"; + memory_.ratio_coords_ = "0.22"; update_config(); tiledb_array_t* array = nullptr; @@ -1800,6 +1765,9 @@ TEST_CASE_METHOD( void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { reset_config(); + memory_ = instance.memory; + update_config(); + // the tile extent is 2 create_default_array_1d(true); From 40e2ad6db1b591df9d63ce461f806ef2e0716ece Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 11 Dec 2024 10:50:22 -0500 Subject: [PATCH 037/228] Re-name new fields --- .../readers/sparse_global_order_reader.cc | 31 ++++++++++++------- .../readers/sparse_global_order_reader.h | 16 ++++++---- 2 files changed, 29 insertions(+), 18 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index ef3f211c7ac..ccdd02e3096 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -155,7 +155,7 @@ Status SparseGlobalOrderReader::dowork() { // Determine result tile order // (this happens after load_initial_data which identifies which tiles pass // subarray) - if (result_tile_ids_.empty()) { + if (preprocess_tile_order_.tiles_.empty()) { compute_result_tile_order(); } @@ -166,7 +166,8 @@ Status SparseGlobalOrderReader::dowork() { !array_schema_.allows_dups() && purge_deletes_consolidation_; // Load tile offsets, if required. - // FIXME: only needs to load offsets in result_tile_ids_ + // TODO: this can be improved to load only the offsets from + // `preprocess_tile_orders_.tiles_`. load_all_tile_offsets(); // Field names to process. @@ -526,8 +527,8 @@ void SparseGlobalOrderReader::compute_result_tile_order() { abort(); // TODO } - result_tile_ids_ = merged_result_tiles; - result_tile_cursor_ = 0; + preprocess_tile_order_.tiles_ = merged_result_tiles; + preprocess_tile_order_.cursor_ = 0; } template @@ -547,11 +548,13 @@ SparseGlobalOrderReader::create_result_tiles( rt_list_num_tiles[i] = result_tiles[i].size(); } - if (result_tile_cursor_ < result_tile_ids_.size()) { + if (preprocess_tile_order_.cursor_ < preprocess_tile_order_.tiles_.size()) { size_t rt; - for (rt = result_tile_cursor_; rt < result_tile_ids_.size(); rt++) { - const auto f = result_tile_ids_[rt].fragment_idx_; - const auto t = result_tile_ids_[rt].tile_idx_; + for (rt = preprocess_tile_order_.cursor_; + rt < preprocess_tile_order_.tiles_.size(); + rt++) { + const auto f = preprocess_tile_order_.tiles_[rt].fragment_idx_; + const auto t = preprocess_tile_order_.tiles_[rt].tile_idx_; auto budget_exceeded = add_result_tile( num_dims, @@ -597,13 +600,17 @@ SparseGlobalOrderReader::create_result_tiles( } // update position for next iteration - result_tile_cursor_ = rt; + preprocess_tile_order_.cursor_ = rt; - if (result_tile_cursor_ == result_tile_ids_.size()) { + if (preprocess_tile_order_.cursor_ == + preprocess_tile_order_.tiles_.size()) { // TODO: original version sets a flag in tmp_read_state_ on a per-fragment // basis, does that have any effect other than computing this? read_state_.set_done_adding_result_tiles(true); + // TODO: would we gain anything from being more precise by checking + // which fragments have nothing remaining in the preprocess list + // in the general case? for (unsigned f = 0; f < num_fragments; f++) { tmp_read_state_.set_all_tiles_loaded(f); } @@ -968,9 +975,9 @@ bool SparseGlobalOrderReader::add_next_cell_to_queue( // If the cell value exceeds the lower bound of the un-populated result // tiles then it is not correct to emit it; hopefully we cleared out // a tile somewhere and trying again will make progress - if (result_tile_cursor_ < result_tile_ids_.size()) { + if (preprocess_tile_order_.cursor_ < preprocess_tile_order_.tiles_.size()) { const auto& next_global_order_tile = - result_tile_ids_[result_tile_cursor_]; + preprocess_tile_order_.tiles_[preprocess_tile_order_.cursor_]; const auto& emit_bound = fragment_metadata_[next_global_order_tile.fragment_idx_]->mbr( next_global_order_tile.tile_idx_); diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index ca88f4466c2..b8c9bdb0339 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -137,13 +137,17 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, std::vector result_tiles_leftover_; /** - * IDs of result tiles, arranged in global order. - * Note that tiles from different fragments may overlap - * (and may need to be de-duplicated if the schema requires unique - * coordinates). + * State for the optional mode to preprocess the tile MBRs + * and merge them into a single globally-ordered list prior + * to loading any tiles. + * + * Tile identifiers in this list are sorted using their starting ranges + * and have already had the subarray (if any) applied. */ - std::vector result_tile_ids_; - size_t result_tile_cursor_; + struct { + std::vector tiles_; + size_t cursor_; + } preprocess_tile_order_; /** Enables consolidation with timestamps or not. */ bool consolidation_with_timestamps_; From 5435a87314ae03734ba4b09cc57d495e8ce2a64c Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 11 Dec 2024 13:36:56 -0500 Subject: [PATCH 038/228] Fix budget for fragment skew test --- test/src/unit-sparse-global-order-reader.cc | 3 +++ 1 file changed, 3 insertions(+) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 1f5f0a27a15..3b7071c3d8c 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -820,6 +820,9 @@ TEST_CASE_METHOD( instance.fragments.push_back(fragment1); instance.num_user_cells = num_user_cells; + instance.memory.total_budget_ = "20000"; + instance.memory.ratio_array_data_ = "0.5"; + run_1d(instance); }; From 9b849111584dd1028e4d134000988c219a12a27a Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 11 Dec 2024 13:38:14 -0500 Subject: [PATCH 039/228] Add config switch to run old code by default --- tiledb/api/c_api/config/config_api_external.h | 8 + tiledb/sm/config/config.cc | 7 +- tiledb/sm/config/config.h | 3 + .../readers/sparse_global_order_reader.cc | 235 ++++++++++++++---- .../readers/sparse_global_order_reader.h | 45 +++- 5 files changed, 251 insertions(+), 47 deletions(-) diff --git a/tiledb/api/c_api/config/config_api_external.h b/tiledb/api/c_api/config/config_api_external.h index 7ef312d085c..c99f6ebad60 100644 --- a/tiledb/api/c_api/config/config_api_external.h +++ b/tiledb/api/c_api/config/config_api_external.h @@ -257,6 +257,14 @@ TILEDB_EXPORT void tiledb_config_free(tiledb_config_t** config) TILEDB_NOEXCEPT; * Which reader to use for sparse global order queries. "refactored" * or "legacy".
* **Default**: refactored + * - `sm.query.sparse_global_order.preprocess_tile_merge`
+ * Performance configuration for sparse global order read queries. + * If `true`, prior to loading the first tiles, the reader will run + * a preprocessing step to arrange tiles from all fragments in a single + * globally ordered list. This is expected to improve performance when + * there are many fragments or when the distribution in space of the + * tiles amongst the fragments is skewed. + * **Default**: "false" * - `sm.query.sparse_unordered_with_dups.reader`
* Which reader to use for sparse unordered with dups queries. * "refactored" or "legacy".
diff --git a/tiledb/sm/config/config.cc b/tiledb/sm/config/config.cc index 4e15c56702c..4c7499112f7 100644 --- a/tiledb/sm/config/config.cc +++ b/tiledb/sm/config/config.cc @@ -118,6 +118,8 @@ const std::string Config::SM_MEMORY_BUDGET_VAR = "10737418240"; // 10GB const std::string Config::SM_QUERY_DENSE_QC_COORDS_MODE = "false"; const std::string Config::SM_QUERY_DENSE_READER = "refactored"; const std::string Config::SM_QUERY_SPARSE_GLOBAL_ORDER_READER = "refactored"; +const std::string Config::SM_QUERY_SPARSE_GLOBAL_ORDER_PREPROCESS_TILE_MERGE = + "false"; const std::string Config::SM_QUERY_SPARSE_UNORDERED_WITH_DUPS_READER = "refactored"; const std::string Config::SM_MEM_MALLOC_TRIM = "true"; @@ -315,6 +317,9 @@ const std::map default_config_values = { std::make_pair( "sm.query.sparse_global_order.reader", Config::SM_QUERY_SPARSE_GLOBAL_ORDER_READER), + std::make_pair( + "sm.query.sparse_global_order.preprocess_tile_merge", + Config::SM_QUERY_SPARSE_GLOBAL_ORDER_PREPROCESS_TILE_MERGE), std::make_pair( "sm.query.sparse_unordered_with_dups.reader", Config::SM_QUERY_SPARSE_UNORDERED_WITH_DUPS_READER), @@ -522,7 +527,7 @@ const std::map default_config_values = { "vfs.hdfs.kerb_ticket_cache_path", Config::VFS_HDFS_KERB_TICKET_CACHE_PATH), std::make_pair("filestore.buffer_size", Config::FILESTORE_BUFFER_SIZE), -}; +}; // namespace tiledb::sm /* ****************************** */ /* PRIVATE CONSTANTS */ diff --git a/tiledb/sm/config/config.h b/tiledb/sm/config/config.h index ef8dda564ca..f4c757c33d4 100644 --- a/tiledb/sm/config/config.h +++ b/tiledb/sm/config/config.h @@ -233,6 +233,9 @@ class Config { /** Which reader to use for sparse global order queries. */ static const std::string SM_QUERY_SPARSE_GLOBAL_ORDER_READER; + /** If `true`, run preprocessing merge step in sparse global order reader */ + static const std::string SM_QUERY_SPARSE_GLOBAL_ORDER_PREPROCESS_TILE_MERGE; + /** Which reader to use for sparse unordered with dups queries. */ static const std::string SM_QUERY_SPARSE_UNORDERED_WITH_DUPS_READER; diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index ccdd02e3096..c405e362238 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -98,6 +98,16 @@ SparseGlobalOrderReader::SparseGlobalOrderReader( , tile_offsets_loaded_(false) { // Initialize memory budget variables. refresh_config(); + + preprocess_tile_order_.enabled_ = + config_.get("sm.query.sparse_global_order.preprocess_tile_merge") + .value_or(false); + preprocess_tile_order_.cursor_ = 0; + + if (!preprocess_tile_order_.enabled_) { + all_fragment_tile_order_.memory_used_for_coords_.resize( + array_->fragment_metadata().size()); + } } /* ****************************** */ @@ -155,8 +165,9 @@ Status SparseGlobalOrderReader::dowork() { // Determine result tile order // (this happens after load_initial_data which identifies which tiles pass // subarray) - if (preprocess_tile_order_.tiles_.empty()) { - compute_result_tile_order(); + if (preprocess_tile_order_.enabled_ && + preprocess_tile_order_.tiles_.empty()) { + preprocess_compute_result_tile_order(); } purge_deletes_consolidation_ = !deletes_consolidation_no_purge_ && @@ -323,7 +334,6 @@ uint64_t SparseGlobalOrderReader::get_coord_tiles_size( template bool SparseGlobalOrderReader::add_result_tile( const unsigned dim_num, - const uint64_t memory_budget_coords_tiles, const unsigned f, const uint64_t t, const FragmentMetadata& frag_md, @@ -336,13 +346,26 @@ bool SparseGlobalOrderReader::add_result_tile( auto tiles_size = get_coord_tiles_size(dim_num, f, t); // Don't load more tiles than the memory budget. - if (memory_used_for_coords_total_ + tiles_size > memory_budget_coords_tiles) { - return true; + if (preprocess_tile_order_.enabled_) { + if (memory_used_for_coords_total_ + tiles_size > + memory_budget_.coordinates_budget()) { + return true; + } + } else { + if (all_fragment_tile_order_.memory_used_for_coords_[f] + tiles_size > + all_fragment_tile_order_.per_fragment_memory_) { + return true; + } } // Adjust total memory used. memory_used_for_coords_total_ += tiles_size; + if (!preprocess_tile_order_.enabled_) { + // Adjust per fragment memory used. + all_fragment_tile_order_.memory_used_for_coords_[f] += tiles_size; + } + // Add the tile. result_tiles[f].emplace_back( f, @@ -360,7 +383,8 @@ bool SparseGlobalOrderReader::add_result_tile( * subarray (e.g. by calling `load_initial_data`) */ template -void SparseGlobalOrderReader::compute_result_tile_order() { +void SparseGlobalOrderReader< + BitmapType>::preprocess_compute_result_tile_order() { const auto& relevant_fragments = subarray_.relevant_fragments(); const uint64_t num_relevant_fragments = relevant_fragments.size(); @@ -537,10 +561,6 @@ SparseGlobalOrderReader::create_result_tiles( std::vector& result_tiles) { auto timer_se = stats_->start_timer("create_result_tiles"); - // For easy reference. - const auto num_fragments = fragment_metadata_.size(); - const auto num_dims = array_schema_.dim_num(); - // Distinguish between leftover result tiles from the previous `submit` // and result tiles which are being added now std::vector rt_list_num_tiles(result_tiles.size()); @@ -548,6 +568,162 @@ SparseGlobalOrderReader::create_result_tiles( rt_list_num_tiles[i] = result_tiles[i].size(); } + if (preprocess_tile_order_.enabled_) { + create_result_tiles_using_preprocess(result_tiles); + } else { + create_result_tiles_all_fragments(result_tiles); + } + + const auto num_fragments = fragment_metadata_.size(); + bool done_adding_result_tiles = tmp_read_state_.done_adding_result_tiles(); + uint64_t num_rt = 0; + for (unsigned int f = 0; f < num_fragments; f++) { + num_rt += result_tiles[f].size(); + } + + logger_->debug("Done adding result tiles, num result tiles {0}", num_rt); + + if (done_adding_result_tiles) { + logger_->debug("All result tiles loaded"); + } + + read_state_.set_done_adding_result_tiles(done_adding_result_tiles); + + // Return the list of tiles added. + std::vector created_tiles; + for (uint64_t i = 0; i < result_tiles.size(); i++) { + TileListIt it = result_tiles[i].begin(); + std::advance(it, rt_list_num_tiles[i]); + for (; it != result_tiles[i].end(); ++it) { + created_tiles.emplace_back(&*it); + } + } + + return created_tiles; +} + +template +void SparseGlobalOrderReader::create_result_tiles_all_fragments( + std::vector& result_tiles) { + // For easy reference. + auto fragment_num = fragment_metadata_.size(); + auto dim_num = array_schema_.dim_num(); + + // Get the number of fragments to process and compute per fragment memory. + uint64_t num_fragments_to_process = + tmp_read_state_.num_fragments_to_process(); + all_fragment_tile_order_.per_fragment_memory_ = + memory_budget_.total_budget() * memory_budget_.ratio_coords() / + num_fragments_to_process; + + // Save which result tile list is empty. + std::vector rt_list_num_tiles(result_tiles.size()); + for (uint64_t i = 0; i < result_tiles.size(); i++) { + rt_list_num_tiles[i] = result_tiles[i].size(); + } + + // Create result tiles. + if (subarray_.is_set()) { + // Load as many tiles as the memory budget allows. + throw_if_not_ok(parallel_for( + &resources_.compute_tp(), 0, fragment_num, [&](uint64_t f) { + uint64_t t = 0; + auto& tile_ranges = tmp_read_state_.tile_ranges(f); + while (!tile_ranges.empty()) { + auto& range = tile_ranges.back(); + for (t = range.first; t <= range.second; t++) { + auto budget_exceeded = add_result_tile( + dim_num, f, t, *fragment_metadata_[f], result_tiles); + + if (budget_exceeded) { + logger_->debug( + "Budget exceeded adding result tiles, fragment {0}, tile " + "{1}", + f, + t); + + if (result_tiles[f].empty()) { + auto tiles_size = get_coord_tiles_size(dim_num, f, t); + throw SparseGlobalOrderReaderException( + "Cannot load a single tile for fragment, increase " + "memory " + "budget, tile size : " + + std::to_string(tiles_size) + ", per fragment memory " + + std::to_string( + all_fragment_tile_order_.per_fragment_memory_) + + ", total budget " + + std::to_string(memory_budget_.total_budget()) + + ", num fragments to process " + + std::to_string(num_fragments_to_process)); + } + return Status::Ok(); + } + + range.first++; + } + + tmp_read_state_.remove_tile_range(f); + } + + tmp_read_state_.set_all_tiles_loaded(f); + + return Status::Ok(); + })); + } else { + // Load as many tiles as the memory budget allows. + throw_if_not_ok(parallel_for( + &resources_.compute_tp(), 0, fragment_num, [&](uint64_t f) { + uint64_t t = 0; + auto tile_num = fragment_metadata_[f]->tile_num(); + + // Figure out the start index. + auto start = read_state_.frag_idx()[f].tile_idx_; + if (!result_tiles[f].empty()) { + start = std::max(start, result_tiles[f].back().tile_idx() + 1); + } + + for (t = start; t < tile_num; t++) { + auto budget_exceeded = add_result_tile( + dim_num, f, t, *fragment_metadata_[f], result_tiles); + + if (budget_exceeded) { + logger_->debug( + "Budget exceeded adding result tiles, fragment {0}, tile " + "{1}", + f, + t); + + if (result_tiles[f].empty()) { + auto tiles_size = get_coord_tiles_size(dim_num, f, t); + return logger_->status(Status_SparseGlobalOrderReaderError( + "Cannot load a single tile for fragment, increase memory " + "budget, tile size : " + + std::to_string(tiles_size) + ", per fragment memory " + + std::to_string( + all_fragment_tile_order_.per_fragment_memory_) + + ", total budget " + + std::to_string(memory_budget_.total_budget()) + + ", num fragments to process " + + std::to_string(num_fragments_to_process))); + } + return Status::Ok(); + } + } + + tmp_read_state_.set_all_tiles_loaded(f); + + return Status::Ok(); + })); + } +} + +template +void SparseGlobalOrderReader::create_result_tiles_using_preprocess( + std::vector& result_tiles) { + // For easy reference. + const auto num_fragments = fragment_metadata_.size(); + const auto num_dims = array_schema_.dim_num(); + if (preprocess_tile_order_.cursor_ < preprocess_tile_order_.tiles_.size()) { size_t rt; for (rt = preprocess_tile_order_.cursor_; @@ -556,13 +732,8 @@ SparseGlobalOrderReader::create_result_tiles( const auto f = preprocess_tile_order_.tiles_[rt].fragment_idx_; const auto t = preprocess_tile_order_.tiles_[rt].tile_idx_; - auto budget_exceeded = add_result_tile( - num_dims, - memory_budget_.coordinates_budget(), - f, - t, - *fragment_metadata_[f], - result_tiles); + auto budget_exceeded = + add_result_tile(num_dims, f, t, *fragment_metadata_[f], result_tiles); if (budget_exceeded) { logger_->debug( @@ -616,32 +787,6 @@ SparseGlobalOrderReader::create_result_tiles( } } } - - bool done_adding_result_tiles = tmp_read_state_.done_adding_result_tiles(); - uint64_t num_rt = 0; - for (unsigned int f = 0; f < num_fragments; f++) { - num_rt += result_tiles[f].size(); - } - - logger_->debug("Done adding result tiles, num result tiles {0}", num_rt); - - if (done_adding_result_tiles) { - logger_->debug("All result tiles loaded"); - } - - read_state_.set_done_adding_result_tiles(done_adding_result_tiles); - - // Return the list of tiles added. - std::vector created_tiles; - for (uint64_t i = 0; i < result_tiles.size(); i++) { - TileListIt it = result_tiles[i].begin(); - std::advance(it, rt_list_num_tiles[i]); - for (; it != result_tiles[i].end(); ++it) { - created_tiles.emplace_back(&*it); - } - } - - return created_tiles; } template @@ -2372,6 +2517,10 @@ void SparseGlobalOrderReader::remove_result_tile( auto tiles_size = get_coord_tiles_size(array_schema_.dim_num(), frag_idx, tile_idx); + if (!preprocess_tile_order_.enabled_) { + all_fragment_tile_order_.memory_used_for_coords_[frag_idx] -= tiles_size; + } + // Adjust total memory usage. memory_used_for_coords_total_ -= tiles_size; diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index b8c9bdb0339..1cb52c2c348 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -145,10 +145,24 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, * and have already had the subarray (if any) applied. */ struct { + bool enabled_; std::vector tiles_; size_t cursor_; } preprocess_tile_order_; + /** + * State for the default mode to evenly distribute memory + * budget amongst the fragments and create a result + * tile per fragment regardless of how their tiles + * fit in the unified global order. + */ + struct { + /** Memory used for coordinates tiles per fragment */ + std::vector memory_used_for_coords_; + /** Memory budget per fragment */ + double per_fragment_memory_; + } all_fragment_tile_order_; + /** Enables consolidation with timestamps or not. */ bool consolidation_with_timestamps_; @@ -213,7 +227,6 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, * Add a result tile to process, making sure maximum budget is respected. * * @param dim_num Number of dimensions. - * @param memory_budget_coords_tiles Memory budget for coordinate tiles. * @param f Fragment index. * @param t Tile index. * @param frag_md Fragment metadata. @@ -223,13 +236,17 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, */ bool add_result_tile( const unsigned dim_num, - const uint64_t memory_budget_coords_tiles, const unsigned f, const uint64_t t, const FragmentMetadata& frag_md, std::vector& result_tiles); - void compute_result_tile_order(); + /** + * Computes the single list of tiles across all fragments + * arranged in the order they must be processed for this query. + * See `preprocess_tile_order_`. + */ + void preprocess_compute_result_tile_order(); /** * Create the result tiles. @@ -240,6 +257,28 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, std::vector create_result_tiles( std::vector& result_tiles); + /** + * Create the result tiles naively, without coordinating + * the ranges of tiles of each fragment. This uses a + * per-fragment memory budget, and (assuming enough memory) + * creates at least one result tile for each fragment. + * + * See `all_fragment_tile_order_`. + * + * @param result_tiles [in-out] Result tiles per fragment. + */ + void create_result_tiles_all_fragments( + std::vector& result_tiles); + + /** + * Create the result tiles using the pre-processed + * tile order. See `preprocess_tile_order_`. + * + * @param result_tiles [in-out] Result tiles per fragment. + */ + void create_result_tiles_using_preprocess( + std::vector& result_tiles); + /** * Clean tiles that have 0 results from the tile lists. * From 9566577eafb4711696d5a29975cd082d9611bd85 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 11 Dec 2024 13:54:30 -0500 Subject: [PATCH 040/228] Fix config unit test --- test/src/unit-capi-config.cc | 3 +++ 1 file changed, 3 insertions(+) diff --git a/test/src/unit-capi-config.cc b/test/src/unit-capi-config.cc index 37a731d0c70..901e8cb2314 100644 --- a/test/src/unit-capi-config.cc +++ b/test/src/unit-capi-config.cc @@ -292,6 +292,7 @@ void check_save_to_file() { ss << "sm.partial_tile_offsets_loading false\n"; ss << "sm.query.dense.qc_coords_mode false\n"; ss << "sm.query.dense.reader refactored\n"; + ss << "sm.query.sparse_global_order.preprocess_tile_merge false\n"; ss << "sm.query.sparse_global_order.reader refactored\n"; ss << "sm.query.sparse_unordered_with_dups.reader refactored\n"; ss << "sm.read_range_oob warn\n"; @@ -641,6 +642,8 @@ TEST_CASE("C API: Test config iter", "[capi][config]") { all_param_values["sm.memory_budget_var"] = "10737418240"; all_param_values["sm.query.dense.qc_coords_mode"] = "false"; all_param_values["sm.query.dense.reader"] = "refactored"; + all_param_values["sm.query.sparse_global_order.preprocess_tile_merge"] = + "false"; all_param_values["sm.query.sparse_global_order.reader"] = "refactored"; all_param_values["sm.query.sparse_unordered_with_dups.reader"] = "refactored"; all_param_values["sm.mem.consolidation.buffers_weight"] = "1"; From 6d2797e203ebda8ed3ec0195b5397654373080ec Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 11 Dec 2024 19:13:53 -0500 Subject: [PATCH 041/228] Also don't do preprocess mode for hilbert --- tiledb/sm/query/readers/sparse_global_order_reader.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index c405e362238..0c5281ea1c0 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -100,6 +100,7 @@ SparseGlobalOrderReader::SparseGlobalOrderReader( refresh_config(); preprocess_tile_order_.enabled_ = + array_schema_.cell_order() != Layout::HILBERT && config_.get("sm.query.sparse_global_order.preprocess_tile_merge") .value_or(false); preprocess_tile_order_.cursor_ = 0; From d946d2942d831552d50ca9d8e44ba0e26060c334 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 11 Dec 2024 19:15:08 -0500 Subject: [PATCH 042/228] RAII close array in tests and macro to multiplex catch/rapidcheck assertions --- test/src/unit-sparse-global-order-reader.cc | 185 ++++++++++++-------- test/support/tdb_rapidcheck.h | 63 +++++++ 2 files changed, 175 insertions(+), 73 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 3b7071c3d8c..3c759acfa2e 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -87,6 +87,53 @@ struct FxRun1D { MemoryBudget memory; }; +/** + * RAII to make sure we close our arrays so that keeping the same array URI + * open from one test to the next doesn't muck things up + * (this is especially important for rapidcheck) + */ +struct CApiArray { + tiledb_ctx_t* ctx_; + tiledb_array_t* array_; + + CApiArray() + : ctx_(nullptr) + , array_(nullptr) { + } + + CApiArray(tiledb_ctx_t* ctx, const char* uri, tiledb_query_type_t mode) + : ctx_(ctx) + , array_(nullptr) { + auto rc = tiledb_array_alloc(ctx, uri, &array_); + REQUIRE(rc == TILEDB_OK); + rc = tiledb_array_open(ctx, array_, mode); + REQUIRE(rc == TILEDB_OK); + } + + CApiArray(CApiArray&& from) + : ctx_(from.ctx_) + , array_(from.movefrom()) { + } + + ~CApiArray() { + if (array_) { + auto rc = tiledb_array_close(ctx_, array_); + REQUIRE(rc == TILEDB_OK); + tiledb_array_free(&array_); + } + } + + tiledb_array_t* movefrom() { + auto array = array_; + array_ = nullptr; + return array; + } + + operator tiledb_array_t*() const { + return array_; + } +}; + struct CSparseGlobalOrderFx { tiledb_ctx_t* ctx_ = nullptr; tiledb_vfs_t* vfs_ = nullptr; @@ -97,10 +144,15 @@ struct CSparseGlobalOrderFx { MemoryBudget memory_; + template void create_default_array_1d(bool allow_dups = false); + void create_default_array_1d_strings(bool allow_dups = false); + + template void write_1d_fragment( int* coords, uint64_t* coords_size, int* data, uint64_t* data_size); + void write_1d_fragment_strings( int* coords, uint64_t* coords_size, @@ -117,7 +169,7 @@ struct CSparseGlobalOrderFx { int* data, uint64_t* data_size, tiledb_query_t** query = nullptr, - tiledb_array_t** array_ret = nullptr, + CApiArray* array_ret = nullptr, std::vector subarray = {1, 10}); int32_t read_strings( bool set_subarray, @@ -138,6 +190,7 @@ struct CSparseGlobalOrderFx { * Inserts fragments one at a time, then reads them back in global order * and checks that what we read out matches what we put in. */ + template void run_1d(FxRun1D instance); template @@ -182,7 +235,9 @@ CSparseGlobalOrderFx::CSparseGlobalOrderFx() { } CSparseGlobalOrderFx::~CSparseGlobalOrderFx() { - tiledb_array_free(&array_); + if (array_) { + tiledb_array_free(&array_); + } remove_dir(temp_dir_, ctx_, vfs_); tiledb_ctx_free(&ctx_); tiledb_vfs_free(&vfs_); @@ -251,16 +306,17 @@ void CSparseGlobalOrderFx::update_config() { tiledb_config_free(&config); } +template void CSparseGlobalOrderFx::create_default_array_1d(bool allow_dups) { int domain[] = {1, 200}; int tile_extent = 2; tiledb_object_t type; auto rc = tiledb_object_type(ctx_, array_name_.c_str(), &type); - REQUIRE(rc == TILEDB_OK); + RCCATCH_REQUIRE(rc == TILEDB_OK); if (type == TILEDB_ARRAY) { rc = tiledb_array_delete(ctx_, array_name_.c_str()); - REQUIRE(rc == TILEDB_OK); + RCCATCH_REQUIRE("" == error_if_any(rc)); } create_array( @@ -302,33 +358,34 @@ void CSparseGlobalOrderFx::create_default_array_1d_strings(bool allow_dups) { allow_dups); } +template void CSparseGlobalOrderFx::write_1d_fragment( int* coords, uint64_t* coords_size, int* data, uint64_t* data_size) { // Open array for writing. tiledb_array_t* array; auto rc = tiledb_array_alloc(ctx_, array_name_.c_str(), &array); - REQUIRE(rc == TILEDB_OK); + RCCATCH_REQUIRE(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); - REQUIRE(rc == TILEDB_OK); + RCCATCH_REQUIRE(rc == TILEDB_OK); // Create the query. tiledb_query_t* query; rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); - REQUIRE(rc == TILEDB_OK); + RCCATCH_REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); - REQUIRE(rc == TILEDB_OK); + RCCATCH_REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer(ctx_, query, "a", data, data_size); - REQUIRE(rc == TILEDB_OK); + RCCATCH_REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer(ctx_, query, "d", coords, coords_size); - REQUIRE(rc == TILEDB_OK); + RCCATCH_REQUIRE(rc == TILEDB_OK); // Submit query. rc = tiledb_query_submit(ctx_, query); - REQUIRE("" == error_if_any(rc)); + RCCATCH_REQUIRE("" == error_if_any(rc)); // Close array. rc = tiledb_array_close(ctx_, array); - REQUIRE("" == error_if_any(rc)); + RCCATCH_REQUIRE("" == error_if_any(rc)); // Clean up. tiledb_array_free(&array); @@ -421,18 +478,14 @@ int32_t CSparseGlobalOrderFx::read( int* data, uint64_t* data_size, tiledb_query_t** query_ret, - tiledb_array_t** array_ret, + CApiArray* array_ret, std::vector subarray) { // Open array for reading. - tiledb_array_t* array; - auto rc = tiledb_array_alloc(ctx_, array_name_.c_str(), &array); - CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx_, array, TILEDB_READ); - CHECK(rc == TILEDB_OK); + CApiArray array(ctx_, array_name_.c_str(), TILEDB_READ); // Create query. tiledb_query_t* query; - rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); + auto rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); CHECK(rc == TILEDB_OK); if (set_subarray) { @@ -488,14 +541,11 @@ int32_t CSparseGlobalOrderFx::read( // Submit query. auto ret = tiledb_query_submit(ctx_, query); if (query_ret == nullptr || array_ret == nullptr) { - // Clean up. - rc = tiledb_array_close(ctx_, array); - CHECK(rc == TILEDB_OK); - tiledb_array_free(&array); + // Clean up (RAII will do it for the array) tiledb_query_free(&query); } else { *query_ret = query; - *array_ret = array; + new (array_ret) CApiArray(std::move(array)); } return ret; @@ -639,7 +689,7 @@ TEST_CASE_METHOD( // Failure here occurs with the value of 0.1 for ratio_tile_ranges_. update_config(); - tiledb_array_t* array = nullptr; + CApiArray array; tiledb_query_t* query = nullptr; // Try to read. @@ -728,7 +778,7 @@ TEST_CASE_METHOD( // Failure here occurs with the value of 0.1 for ratio_tile_ranges_. update_config(); - tiledb_array_t* array = nullptr; + CApiArray array; tiledb_query_t* query = nullptr; // Try to read. @@ -793,7 +843,8 @@ TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: fragment skew", "[sparse-global-order]") { - auto doit = [this](size_t fragment_size, size_t num_user_cells) { + auto doit = [this]( + size_t fragment_size, size_t num_user_cells) { // Write a fragment F0 with unique coordinates struct FxFragment1D fragment0; fragment0.coords.resize(fragment_size); @@ -823,18 +874,18 @@ TEST_CASE_METHOD( instance.memory.total_budget_ = "20000"; instance.memory.ratio_array_data_ = "0.5"; - run_1d(instance); + run_1d(instance); }; SECTION("Example") { - doit(200, 8); + doit.operator()(200, 8); } SECTION("Rapidcheck") { rc::prop("rapidcheck fragment skew", [doit]() { const size_t fragment_size = *rc::gen::inRange(2, 200); const size_t num_user_cells = *rc::gen::inRange(1, 1024); - doit(fragment_size, num_user_cells); + doit.operator()(fragment_size, num_user_cells); }); } } @@ -857,7 +908,8 @@ TEST_CASE_METHOD( "Sparse global order reader: fragment interleave", "[sparse-global-order]") { // NB: the tile extent is 2 - auto doit = [this](size_t fragment_size, size_t num_user_cells) { + auto doit = [this]( + size_t fragment_size, size_t num_user_cells) { struct FxFragment1D fragment0; struct FxFragment1D fragment1; @@ -889,18 +941,18 @@ TEST_CASE_METHOD( instance.memory.total_budget_ = "20000"; instance.memory.ratio_array_data_ = "0.5"; - run_1d(instance); + run_1d(instance); }; SECTION("Example") { - doit(196, 8); + doit.operator()(196, 8); } SECTION("Rapidcheck") { rc::prop("rapidcheck fragment interleave", [doit]() { const size_t fragment_size = *rc::gen::inRange(2, 196); const size_t num_user_cells = *rc::gen::inRange(1, 1024); - doit(fragment_size, num_user_cells); + doit.operator()(fragment_size, num_user_cells); }); } @@ -1002,7 +1054,7 @@ TEST_CASE_METHOD( memory_.ratio_coords_ = "0.11"; update_config(); - tiledb_array_t* array = nullptr; + CApiArray array; tiledb_query_t* query = nullptr; uint32_t rc; @@ -1049,7 +1101,6 @@ TEST_CASE_METHOD( // Clean up. rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); - tiledb_array_free(&array); tiledb_query_free(&query); } @@ -1151,7 +1202,7 @@ TEST_CASE_METHOD( uint64_t coords_size = sizeof(coords_1); uint64_t data_size = sizeof(data_1); - // Create the aray so the removed tile is at the correct index. + // Create the array so the removed tile is at the correct index. switch (tile_idx) { case 0: write_1d_fragment(coords_3, &coords_size, data_3, &data_size); @@ -1316,7 +1367,7 @@ TEST_CASE_METHOD( uint64_t coords_size = sizeof(coords_1); uint64_t data_size = sizeof(data_1); - // Create the aray. + // Create the array. write_1d_fragment(coords_1, &coords_size, data_1, &data_size); write_1d_fragment(coords_2, &coords_size, data_2, &data_size); @@ -1526,7 +1577,7 @@ TEST_CASE_METHOD( memory_.ratio_coords_ = "0.22"; update_config(); - tiledb_array_t* array = nullptr; + CApiArray array; tiledb_query_t* query = nullptr; // Try to read. @@ -1569,9 +1620,6 @@ TEST_CASE_METHOD( CHECK(rc == TILEDB_OK); // Clean up. - rc = tiledb_array_close(ctx_, array); - CHECK(rc == TILEDB_OK); - tiledb_array_free(&array); tiledb_query_free(&query); } @@ -1594,7 +1642,7 @@ TEST_CASE_METHOD( uint64_t data2_size = sizeof(data2); write_1d_fragment(coords, &coords_size, data2, &data2_size); - tiledb_array_t* array = nullptr; + CApiArray array; tiledb_query_t* query = nullptr; // Read with buffers that can only fit one cell. @@ -1647,9 +1695,6 @@ TEST_CASE_METHOD( CHECK(status == TILEDB_COMPLETED); // Clean up. - rc = tiledb_array_close(ctx_, array); - CHECK(rc == TILEDB_OK); - tiledb_array_free(&array); tiledb_query_free(&query); } @@ -1765,6 +1810,7 @@ TEST_CASE_METHOD( tiledb_query_free(&query); } +template void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { reset_config(); @@ -1772,7 +1818,7 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { update_config(); // the tile extent is 2 - create_default_array_1d(true); + create_default_array_1d(true); // write all fragments for (auto& fragment : instance.fragments) { @@ -1780,12 +1826,12 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { uint64_t atts_size = sizeof(int) * fragment.atts.size(); // precondition: fragment must have the same number of cells for each field - REQUIRE(coords_size == atts_size); + RCCATCH_REQUIRE(coords_size == atts_size); write_1d_fragment( fragment.coords.data(), &coords_size, fragment.atts.data(), &atts_size); - REQUIRE(coords_size == sizeof(int) * fragment.coords.size()); - REQUIRE(atts_size == sizeof(int) * fragment.atts.size()); + RCCATCH_REQUIRE(coords_size == sizeof(int) * fragment.coords.size()); + RCCATCH_REQUIRE(atts_size == sizeof(int) * fragment.atts.size()); } std::vector expectcoords; @@ -1814,25 +1860,21 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { for (const auto i : idxs) { sortatts.push_back(expectatts[i]); } - REQUIRE(sortatts.size() == expectatts.size()); + RCCATCH_REQUIRE(sortatts.size() == expectatts.size()); expectatts = sortatts; std::sort(expectcoords.begin(), expectcoords.end()); } // Open array for reading. - tiledb_array_t* array; - auto rc = tiledb_array_alloc(ctx_, array_name_.c_str(), &array); - CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx_, array, TILEDB_READ); - CHECK(rc == TILEDB_OK); + CApiArray array(ctx_, array_name_.c_str(), TILEDB_READ); // Create query tiledb_query_t* query; - rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); - CHECK(rc == TILEDB_OK); + auto rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); + RCCATCH_REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); - CHECK(rc == TILEDB_OK); + RCCATCH_REQUIRE(rc == TILEDB_OK); // Prepare output buffer std::vector outcoords; @@ -1850,28 +1892,28 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { rc = tiledb_query_set_data_buffer( ctx_, query, "a", &outatts[outcursor], &outatts_size); - CHECK(rc == TILEDB_OK); + RCCATCH_REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( ctx_, query, "d", &outcoords[outcursor], &outcoords_size); - CHECK(rc == TILEDB_OK); + RCCATCH_REQUIRE(rc == TILEDB_OK); rc = tiledb_query_submit(ctx_, query); - REQUIRE("" == error_if_any(rc)); + RCCATCH_REQUIRE("" == error_if_any(rc)); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); - REQUIRE(rc == TILEDB_OK); + RCCATCH_REQUIRE(rc == TILEDB_OK); if (outcoords_size < instance.num_user_cells * sizeof(int)) { - CHECK(status == TILEDB_COMPLETED); + RCCATCH_REQUIRE(status == TILEDB_COMPLETED); } else { - CHECK(outcoords_size == instance.num_user_cells * sizeof(int)); + RCCATCH_REQUIRE(outcoords_size == instance.num_user_cells * sizeof(int)); } - CHECK(outcoords_size % sizeof(int) == 0); + RCCATCH_REQUIRE(outcoords_size % sizeof(int) == 0); outcursor += outcoords_size / sizeof(int); // since they are the same data type - CHECK(outatts_size == outcoords_size); + RCCATCH_REQUIRE(outatts_size == outcoords_size); if (status == TILEDB_COMPLETED) { break; @@ -1879,17 +1921,14 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { } // Clean up. - rc = tiledb_array_close(ctx_, array); - CHECK(rc == TILEDB_OK); - tiledb_array_free(&array); tiledb_query_free(&query); - CHECK(expectcoords == outcoords); + RCCATCH_REQUIRE(expectcoords == outcoords); // Checking attributes is more complicated because equal coords // can manifest their attributes in any order. // Identify the runs of equal coords and then compare using those - REQUIRE(expectatts.size() == outatts.size()); + RCCATCH_REQUIRE(expectatts.size() == outatts.size()); int attcursor = 0; int runlength = 1; for (size_t i = 1; i < expectcoords.size(); i++) { @@ -1901,7 +1940,7 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { expectatts.begin() + attcursor + runlength); std::set outattsrun( outatts.begin() + attcursor, outatts.begin() + attcursor + runlength); - CHECK(expectattsrun == outattsrun); + RCCATCH_REQUIRE(expectattsrun == outattsrun); attcursor += runlength; runlength = 1; } diff --git a/test/support/tdb_rapidcheck.h b/test/support/tdb_rapidcheck.h index 39a30682e78..615cc71ab69 100644 --- a/test/support/tdb_rapidcheck.h +++ b/test/support/tdb_rapidcheck.h @@ -44,4 +44,67 @@ #include #include +#include + +namespace tiledb::test { + +/** + * Marker that a template is instantiated by top-level CATCH code + */ +struct Catch {}; + +/** + * Marker that a template is instantiated by a rapidcheck property + */ +struct Rapidcheck {}; + +} // namespace tiledb::test + +/** + * Helper macro for running an assert in a context + * where it could be either in a top-level catch test, + * or in a rapidcheck property + * (e.g. a function which could be called from either) + * + * Expects a type named `Asserter` to be either `Catch` or `Rapidcheck`. + * + * This expands to REQUIRE for `Catch` and RC_ASSERT for `Rapidcheck`. + * For both type markers this will throw an exception. + */ +#define RCCATCH_REQUIRE(...) \ + do { \ + static_assert( \ + std::is_same::value || \ + std::is_same::value); \ + if (std::is_same::value) { \ + REQUIRE(__VA_ARGS__); \ + } else { \ + RC_ASSERT(__VA_ARGS__); \ + } \ + } while (0) + +/** + * Helper macro for running an assert in a context + * where it could be either in a top-level catch test, + * or in a rapidcheck property + * (e.g. a function which could be called from either) + * + * Expects a type named `Asserter` to be either `Catch` or `Rapidcheck`. + * + * This expands to CHECK for `Catch` and RC_ASSERT for `Rapidcheck`. + * For `Catch`, this will not throw an exception - the test will continue. + * For `Rapidcheck` this will throw an exception. + */ +#define RCCATCH_CHECK(...) \ + do { \ + static_assert( \ + std::is_same_type::::value || \ + std::is_same_type::::value); \ + if (std::is_same_type::::value) { \ + CHECK(__VA_ARGS__); \ + } else { \ + RC_ASSERT(__VA_ARGS__); \ + } \ + } while (0) + #endif // TILEDB_MISC_TDB_RAPIDCHECK_H From 39d6268fcd1c58c778f9b4f1497650a23751dc79 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 12 Dec 2024 09:21:23 -0500 Subject: [PATCH 043/228] Fix slab length --- tiledb/sm/misc/comparators.h | 40 +++++++----- tiledb/sm/misc/type_traits.h | 65 +++++++++++++++++++ tiledb/sm/query/readers/result_coords.h | 5 +- .../readers/sparse_global_order_reader.cc | 35 ++++++++-- 4 files changed, 120 insertions(+), 25 deletions(-) create mode 100644 tiledb/sm/misc/type_traits.h diff --git a/tiledb/sm/misc/comparators.h b/tiledb/sm/misc/comparators.h index f1348ac2a4f..a4f68083228 100644 --- a/tiledb/sm/misc/comparators.h +++ b/tiledb/sm/misc/comparators.h @@ -38,22 +38,39 @@ #include #include -#include "tiledb/common/types/untyped_datum.h" #include "tiledb/sm/array_schema/domain.h" #include "tiledb/sm/enums/layout.h" +#include "tiledb/sm/misc/type_traits.h" #include "tiledb/sm/query/readers/result_coords.h" #include "tiledb/sm/query/readers/sparse_global_order_reader.h" #include "tiledb/sm/query/writers/domain_buffer.h" -using namespace tiledb::common; +namespace stdx { + +/** + * Generic comparator adapter which reverses the comparison arguments. + * For a comparison `c(a, b)`, this returns `c(b, a)`. + */ +template +struct reverse_comparator { + Comparator inner_; + + template + reverse_comparator(Args&&... args) + : inner_(std::forward(args)...) { + } + + template + bool operator()(const L& a, const R& b) const { + return inner_(b, a); + } +}; + +} // namespace stdx namespace tiledb::sm { -template -concept CellCmpable = - requires(const T& a, const Dimension& dim, unsigned dim_idx) { - { a.dimension_datum(dim, dim_idx) } -> std::same_as; - }; +using namespace tiledb::common; namespace cell_compare { template @@ -339,15 +356,6 @@ class HilbertCmpRCI : protected CellCmpBase { } }; -/** - * Concept describing types which can be ordered using `GlobalCmp`. - */ -template -concept GlobalCellCmpable = - CellCmpable and requires(const T& a, const Dimension& dim, unsigned d) { - { a.coord(d) } -> std::convertible_to; - }; - template struct global_order_compare { template diff --git a/tiledb/sm/misc/type_traits.h b/tiledb/sm/misc/type_traits.h new file mode 100644 index 00000000000..25c746755a9 --- /dev/null +++ b/tiledb/sm/misc/type_traits.h @@ -0,0 +1,65 @@ +/** + * @file type_traits.h + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2017-2024 TileDB, Inc. + * @copyright Copyright (c) 2016 MIT and Intel Corporation + * + * 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. + * + * @section DESCRIPTION + * + * Provides type traits (concepts) which contain the interface requirements + * for various templates. + */ + +#ifndef TILEDB_COMPARE_TRAITS_H +#define TILEDB_COMPARE_TRAITS_H + +#include "tiledb/common/types/untyped_datum.h" +#include "tiledb/sm/array_schema/dimension.h" + +namespace tiledb::sm { + +/** + * Concept describing types which can be ordered using `CellCmpBase` + * (see `tiledb/sm/misc/comparators.h`) + */ +template +concept CellCmpable = + requires(const T& a, const Dimension& dim, unsigned dim_idx) { + { a.dimension_datum(dim, dim_idx) } -> std::same_as; + }; + +/** + * Concept describing types which can be ordered using `GlobalCellCmp`. + * (see `tiledb/sm/misc/comparators.h`) + */ +template +concept GlobalCellCmpable = + CellCmpable and requires(const T& a, const Dimension& dim, unsigned d) { + { a.coord(d) } -> std::convertible_to; + }; + +} // namespace tiledb::sm + +#endif diff --git a/tiledb/sm/query/readers/result_coords.h b/tiledb/sm/query/readers/result_coords.h index 7f34535f84a..c2f6b527f0e 100644 --- a/tiledb/sm/query/readers/result_coords.h +++ b/tiledb/sm/query/readers/result_coords.h @@ -38,6 +38,7 @@ #include "tiledb/common/types/dynamic_typed_datum.h" #include "tiledb/sm/array_schema/dimension.h" +#include "tiledb/sm/misc/type_traits.h" #include "tiledb/sm/query/readers/result_tile.h" using namespace tiledb::common; @@ -274,9 +275,9 @@ struct GlobalOrderResultCoords * * @return Max slab length that can be merged for this tile. */ - template + template uint64_t max_slab_length( - const GlobalOrderResultCoords& next, const CompType& cmp) { + const GlobalOrderLowerBound& next, const CompType& cmp) { uint64_t cell_num = base::tile_->cell_num(); // Store the original position. diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 0c5281ea1c0..c193a3d06db 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -34,6 +34,7 @@ #include "tiledb/common/algorithm/parallel_merge.h" #include "tiledb/common/logger.h" #include "tiledb/common/memory_tracker.h" +#include "tiledb/common/unreachable.h" #include "tiledb/sm/array/array.h" #include "tiledb/sm/array_schema/array_schema.h" #include "tiledb/sm/array_schema/dimension.h" @@ -528,7 +529,7 @@ void SparseGlobalOrderReader< break; } default: - abort(); // TODO: rpobably an error? + stdx::unreachable(); } break; case Layout::COL_MAJOR: @@ -544,12 +545,12 @@ void SparseGlobalOrderReader< break; } default: - abort(); // TODO: rpobably an error? + stdx::unreachable(); } break; case Layout::HILBERT: default: - abort(); // TODO + stdx::unreachable(); } preprocess_tile_order_.tiles_ = merged_result_tiles; @@ -1387,11 +1388,31 @@ SparseGlobalOrderReader::merge_result_cell_slabs( // Compute the length of the cell slab. uint64_t length = 1; if (to_process.has_next_ || single_cell_only) { - if (tile_queue.empty()) { - length = to_process.max_slab_length(); + if (preprocess_tile_order_.cursor_ < + preprocess_tile_order_.tiles_.size()) { + // the cell slab may overlap the lower bound of tiles which aren't in + // the queue yet + const auto& next_global_order_tile = + preprocess_tile_order_.tiles_[preprocess_tile_order_.cursor_]; + const auto& emit_bound = + fragment_metadata_[next_global_order_tile.fragment_idx_]->mbr( + next_global_order_tile.tile_idx_); + RangeLowerBound global_order_lower_bound = {.mbr = emit_bound}; + stdx::reverse_comparator cmp(array_schema_.domain()); + if (tile_queue.empty()) { + length = to_process.max_slab_length(global_order_lower_bound, cmp); + } else if (cmp(global_order_lower_bound, tile_queue.top())) { + length = to_process.max_slab_length(global_order_lower_bound, cmp); + } else { + length = to_process.max_slab_length(tile_queue.top(), cmp); + } } else { - length = - to_process.max_slab_length(tile_queue.top(), cmp_max_slab_length); + if (tile_queue.empty()) { + length = to_process.max_slab_length(); + } else { + length = to_process.max_slab_length( + tile_queue.top(), cmp_max_slab_length); + } } } From 333b27d9e8db6720c7a0ab6d7f1004a5b8a15e51 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 12 Dec 2024 09:43:08 -0500 Subject: [PATCH 044/228] DefaultArray1DConfig --- test/src/unit-sparse-global-order-reader.cc | 43 +++++++++++++++------ 1 file changed, 31 insertions(+), 12 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 3c759acfa2e..23f51ddba7d 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -134,6 +134,25 @@ struct CApiArray { } }; +struct DefaultArray1DConfig { + bool allow_dups; + int domain[2]; + int extent; + + DefaultArray1DConfig() + : allow_dups(false) + , extent(2) { + domain[0] = 1; + domain[1] = 200; + } + + DefaultArray1DConfig with_allow_dups(bool allow_dups) const { + auto copy = *this; + copy.allow_dups = allow_dups; + return copy; + } +}; + struct CSparseGlobalOrderFx { tiledb_ctx_t* ctx_ = nullptr; tiledb_vfs_t* vfs_ = nullptr; @@ -145,7 +164,8 @@ struct CSparseGlobalOrderFx { MemoryBudget memory_; template - void create_default_array_1d(bool allow_dups = false); + void create_default_array_1d( + const DefaultArray1DConfig& config = DefaultArray1DConfig()); void create_default_array_1d_strings(bool allow_dups = false); @@ -307,10 +327,8 @@ void CSparseGlobalOrderFx::update_config() { } template -void CSparseGlobalOrderFx::create_default_array_1d(bool allow_dups) { - int domain[] = {1, 200}; - int tile_extent = 2; - +void CSparseGlobalOrderFx::create_default_array_1d( + const DefaultArray1DConfig& config) { tiledb_object_t type; auto rc = tiledb_object_type(ctx_, array_name_.c_str(), &type); RCCATCH_REQUIRE(rc == TILEDB_OK); @@ -325,8 +343,8 @@ void CSparseGlobalOrderFx::create_default_array_1d(bool allow_dups) { TILEDB_SPARSE, {"d"}, {TILEDB_INT32}, - {domain}, - {&tile_extent}, + std::vector{(void*)(&config.domain[0])}, + std::vector{(void*)(&config.extent)}, {"a"}, {TILEDB_INT32}, {1}, @@ -334,7 +352,7 @@ void CSparseGlobalOrderFx::create_default_array_1d(bool allow_dups) { TILEDB_ROW_MAJOR, TILEDB_ROW_MAJOR, 2, - allow_dups); + config.allow_dups); } void CSparseGlobalOrderFx::create_default_array_1d_strings(bool allow_dups) { @@ -1256,7 +1274,7 @@ TEST_CASE_METHOD( bool extra_fragment = GENERATE(true, false); int qc_idx = GENERATE(1, 2); - create_default_array_1d(dups); + create_default_array_1d(DefaultArray1DConfig().with_allow_dups(dups)); int coords_1[] = {1, 2, 3}; int data_1[] = {2, 2, 2}; @@ -1353,7 +1371,7 @@ TEST_CASE_METHOD( "[sparse-global-order][merge][subarray][dups]") { // Create default array. reset_config(); - create_default_array_1d(true); + create_default_array_1d(DefaultArray1DConfig().with_allow_dups(true)); bool use_subarray = false; int qc_idx = GENERATE(1, 2); @@ -1628,7 +1646,7 @@ TEST_CASE_METHOD( "Sparse global order reader: correct read state on duplicates", "[sparse-global-order][no-dups][read-state]") { bool dups = GENERATE(false, true); - create_default_array_1d(dups); + create_default_array_1d(DefaultArray1DConfig().with_allow_dups(dups)); // Write one fragment in coordinates 1-10 with data 1-10. int coords[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; @@ -1818,7 +1836,8 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { update_config(); // the tile extent is 2 - create_default_array_1d(true); + create_default_array_1d( + DefaultArray1DConfig().with_allow_dups(true)); // write all fragments for (auto& fragment : instance.fragments) { From 8611a3496f2ed128dcb1ceb41155c6f61e24e34b Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 12 Dec 2024 10:24:44 -0500 Subject: [PATCH 045/228] Arbitrary extent in fragment skew test --- test/src/unit-sparse-global-order-reader.cc | 52 ++++++++++++--------- 1 file changed, 30 insertions(+), 22 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 23f51ddba7d..d4e30813936 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -77,6 +77,28 @@ struct MemoryBudget { } }; +/** + * Options for configuring the CSparseGlobalFx default 1D array + */ +struct DefaultArray1DConfig { + bool allow_dups; + int domain[2]; + int extent; + + DefaultArray1DConfig() + : allow_dups(false) + , extent(2) { + domain[0] = 1; + domain[1] = 200; + } + + DefaultArray1DConfig with_allow_dups(bool allow_dups) const { + auto copy = *this; + copy.allow_dups = allow_dups; + return copy; + } +}; + /** * An instance of input to `CSparseGlobalOrderFx::run_1d` */ @@ -84,6 +106,7 @@ struct FxRun1D { uint64_t num_user_cells; std::vector fragments; + DefaultArray1DConfig array; MemoryBudget memory; }; @@ -134,25 +157,6 @@ struct CApiArray { } }; -struct DefaultArray1DConfig { - bool allow_dups; - int domain[2]; - int extent; - - DefaultArray1DConfig() - : allow_dups(false) - , extent(2) { - domain[0] = 1; - domain[1] = 200; - } - - DefaultArray1DConfig with_allow_dups(bool allow_dups) const { - auto copy = *this; - copy.allow_dups = allow_dups; - return copy; - } -}; - struct CSparseGlobalOrderFx { tiledb_ctx_t* ctx_ = nullptr; tiledb_vfs_t* vfs_ = nullptr; @@ -862,7 +866,7 @@ TEST_CASE_METHOD( "Sparse global order reader: fragment skew", "[sparse-global-order]") { auto doit = [this]( - size_t fragment_size, size_t num_user_cells) { + size_t fragment_size, size_t num_user_cells, int extent) { // Write a fragment F0 with unique coordinates struct FxFragment1D fragment0; fragment0.coords.resize(fragment_size); @@ -889,6 +893,8 @@ TEST_CASE_METHOD( instance.fragments.push_back(fragment1); instance.num_user_cells = num_user_cells; + instance.array.extent = extent; + instance.memory.total_budget_ = "20000"; instance.memory.ratio_array_data_ = "0.5"; @@ -896,14 +902,16 @@ TEST_CASE_METHOD( }; SECTION("Example") { - doit.operator()(200, 8); + doit.operator()(200, 8, 2); } SECTION("Rapidcheck") { rc::prop("rapidcheck fragment skew", [doit]() { const size_t fragment_size = *rc::gen::inRange(2, 200); const size_t num_user_cells = *rc::gen::inRange(1, 1024); - doit.operator()(fragment_size, num_user_cells); + const int extent = *rc::gen::inRange(1, 200); + doit.operator()( + fragment_size, num_user_cells, extent); }); } } From 1978db028e895d7578f1698f0dd380b18b5b5f8c Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 12 Dec 2024 10:25:07 -0500 Subject: [PATCH 046/228] Arbitrary --- test/src/unit-sparse-global-order-reader.cc | 56 +++++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index d4e30813936..8e4d53022c9 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -1973,3 +1973,59 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { } } } + +namespace rc { +template <> +struct Arbitrary { + static Gen arbitrary() { + // NB: `gen::inRange` is exclusive at the upper end but tiledb domain is + // inclusive. So we have to use `int64_t` to avoid overflow. + auto domain = gen::mapcat(gen::arbitrary(), [](int lb) { + return gen::pair( + gen::just(lb), + gen::cast(gen::inRange( + int64_t(lb), int64_t(std::numeric_limits::max()) + 1))); + }); + + auto coord = gen::mapcat(domain, [](std::pair domain) { + return gen::cast( + gen::inRange(int64_t(domain.first), int64_t(domain.second) + 1)); + }); + + auto dimension = gen::mapcat(domain, [](std::pair domain) { + auto extent_lower_bound = 1; + auto extent_upper_bound = std::min( + 1024 * 16, int(int64_t(domain.second) - int64_t(domain.first) + 1)); + auto extent = gen::inRange(extent_lower_bound, extent_upper_bound); + return gen::tuple( + gen::just(domain.first), gen::just(domain.second), extent); + }); + + auto fragment = gen::mapcat( + gen::container>(coord), [](std::vector coords) { + return gen::map( + gen::container>( + coords.size(), gen::arbitrary()), + [coords](std::vector atts) { + return FxFragment1D{.coords = coords, .atts = atts}; + }); + }); + + auto fragments = gen::container>(fragment); + + return gen::apply( + [](std::vector fragments, + std::tuple dimension) { + FxRun1D instance; + instance.fragments = fragments; + std::tie( + instance.array.domain[0], + instance.array.domain[1], + instance.array.extent) = dimension; + return instance; + }, + fragments, + dimension); + } +}; +} // namespace rc From 02bb56ecaf415b1952fb8961728732367117b523 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 12 Dec 2024 10:51:02 -0500 Subject: [PATCH 047/228] Fix queue-to-bound comparison --- tiledb/sm/query/readers/sparse_global_order_reader.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index c193a3d06db..67593cef492 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -1401,7 +1401,7 @@ SparseGlobalOrderReader::merge_result_cell_slabs( stdx::reverse_comparator cmp(array_schema_.domain()); if (tile_queue.empty()) { length = to_process.max_slab_length(global_order_lower_bound, cmp); - } else if (cmp(global_order_lower_bound, tile_queue.top())) { + } else if (cmp(tile_queue.top(), global_order_lower_bound)) { length = to_process.max_slab_length(global_order_lower_bound, cmp); } else { length = to_process.max_slab_length(tile_queue.top(), cmp); From d4c7e7f90a4aef85fc309b6d35ca0a4af0623ca1 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 12 Dec 2024 13:51:20 -0500 Subject: [PATCH 048/228] Use CApiArray to RAII close in write_1d_fragment --- test/src/unit-sparse-global-order-reader.cc | 13 ++----------- 1 file changed, 2 insertions(+), 11 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 8e4d53022c9..7128b2faa96 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -384,15 +384,11 @@ template void CSparseGlobalOrderFx::write_1d_fragment( int* coords, uint64_t* coords_size, int* data, uint64_t* data_size) { // Open array for writing. - tiledb_array_t* array; - auto rc = tiledb_array_alloc(ctx_, array_name_.c_str(), &array); - RCCATCH_REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); - RCCATCH_REQUIRE(rc == TILEDB_OK); + CApiArray array(ctx_, array_name_.c_str(), TILEDB_WRITE); // Create the query. tiledb_query_t* query; - rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); + auto rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); RCCATCH_REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); RCCATCH_REQUIRE(rc == TILEDB_OK); @@ -405,12 +401,7 @@ void CSparseGlobalOrderFx::write_1d_fragment( rc = tiledb_query_submit(ctx_, query); RCCATCH_REQUIRE("" == error_if_any(rc)); - // Close array. - rc = tiledb_array_close(ctx_, array); - RCCATCH_REQUIRE("" == error_if_any(rc)); - // Clean up. - tiledb_array_free(&array); tiledb_query_free(&query); } From b70634a7e02fce917fcda7d5d6207ef19527bc8d Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 12 Dec 2024 14:29:21 -0500 Subject: [PATCH 049/228] rapidcheck sparse global order test for arbitrary 1D fragment set --- test/src/unit-sparse-global-order-reader.cc | 119 +++++++++++++++----- 1 file changed, 92 insertions(+), 27 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 7128b2faa96..2044f0a4e88 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -1835,8 +1835,7 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { update_config(); // the tile extent is 2 - create_default_array_1d( - DefaultArray1DConfig().with_allow_dups(true)); + create_default_array_1d(instance.array); // write all fragments for (auto& fragment : instance.fragments) { @@ -1846,7 +1845,7 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { // precondition: fragment must have the same number of cells for each field RCCATCH_REQUIRE(coords_size == atts_size); - write_1d_fragment( + write_1d_fragment( fragment.coords.data(), &coords_size, fragment.atts.data(), &atts_size); RCCATCH_REQUIRE(coords_size == sizeof(int) * fragment.coords.size()); RCCATCH_REQUIRE(atts_size == sizeof(int) * fragment.atts.size()); @@ -1972,51 +1971,117 @@ struct Arbitrary { // NB: `gen::inRange` is exclusive at the upper end but tiledb domain is // inclusive. So we have to use `int64_t` to avoid overflow. auto domain = gen::mapcat(gen::arbitrary(), [](int lb) { + auto ub_limit = int64_t(std::numeric_limits::max()) + 1; return gen::pair( - gen::just(lb), - gen::cast(gen::inRange( - int64_t(lb), int64_t(std::numeric_limits::max()) + 1))); - }); - - auto coord = gen::mapcat(domain, [](std::pair domain) { - return gen::cast( - gen::inRange(int64_t(domain.first), int64_t(domain.second) + 1)); + gen::just(lb), gen::cast(gen::inRange(int64_t(lb), ub_limit))); }); auto dimension = gen::mapcat(domain, [](std::pair domain) { auto extent_lower_bound = 1; auto extent_upper_bound = std::min( 1024 * 16, int(int64_t(domain.second) - int64_t(domain.first) + 1)); - auto extent = gen::inRange(extent_lower_bound, extent_upper_bound); + auto extent = gen::inRange(extent_lower_bound, extent_upper_bound + 1); return gen::tuple( gen::just(domain.first), gen::just(domain.second), extent); }); - auto fragment = gen::mapcat( - gen::container>(coord), [](std::vector coords) { - return gen::map( - gen::container>( - coords.size(), gen::arbitrary()), - [coords](std::vector atts) { - return FxFragment1D{.coords = coords, .atts = atts}; - }); + auto fragments = + gen::mapcat(dimension, [](std::tuple dimension) { + int coord_lb, coord_ub; + std::tie(coord_lb, coord_ub, std::ignore) = dimension; + auto coord = gen::cast( + gen::inRange(int64_t(coord_lb), int64_t(coord_ub) + 1)); + + auto coords = gen::suchThat( + gen::container>(coord), + [](std::vector coords) { return !coords.empty(); }); + + auto fragment = gen::mapcat(coords, [](std::vector coords) { + return gen::map( + gen::container>( + coords.size(), gen::arbitrary()), + [coords](std::vector atts) { + return FxFragment1D{.coords = coords, .atts = atts}; + }); + }); + + return gen::pair( + gen::just(dimension), + gen::suchThat( + gen::container>(fragment), + [](auto fragments) { return !fragments.empty(); })); }); - auto fragments = gen::container>(fragment); - return gen::apply( - [](std::vector fragments, - std::tuple dimension) { + [](std::pair, std::vector> + fragments) { FxRun1D instance; - instance.fragments = fragments; + + std::tuple dimension; + std::tie(dimension, instance.fragments) = fragments; + instance.array.allow_dups = true; std::tie( instance.array.domain[0], instance.array.domain[1], instance.array.extent) = dimension; return instance; }, - fragments, - dimension); + fragments); } }; + +template <> +void show(const FxRun1D& instance, std::ostream& os) { + size_t f = 0; + + os << "{" << std::endl; + os << "\t\"fragments\": [" << std::endl; + for (const auto& fragment : instance.fragments) { + os << "\t\t{" << std::endl; + os << "\t\t\t\"coords\": [" << std::endl; + os << "\t\t\t\t"; + show(fragment.coords, os); + os << std::endl; + os << "\t\t\t], " << std::endl; + os << "\t\t\t\"atts\": [" << std::endl; + os << "\t\t\t\t"; + show(fragment.atts, os); + os << std::endl; + os << "\t\t\t] " << std::endl; + os << "\t\t}"; + if ((f++) + 1 < instance.fragments.size()) { + os << ", " << std::endl; + } else { + os << std::endl; + } + } + os << "\t]," << std::endl; + os << "\t\"num_user_cells\": " << instance.num_user_cells << std::endl; + os << "\t\"array\": {" << std::endl; + os << "\t\t\"allow_dups\": " << instance.array.allow_dups << std::endl; + os << "\t\t\"domain\": [" << instance.array.domain[0] << ", " + << instance.array.domain[1] << "]," << std::endl; + os << "\t\t\"extent\": " << instance.array.extent << std::endl; + os << "\t}," << std::endl; + os << "\t\"memory\": {" << std::endl; + os << "\t\t\"total_budget\": " << instance.memory.total_budget_ << ", " + << std::endl; + os << "\t\t\"ratio_tile_ranges\": " << instance.memory.ratio_tile_ranges_ + << ", " << std::endl; + os << "\t\t\"ratio_array_data\": " << instance.memory.ratio_array_data_ + << ", " << std::endl; + os << "\t\t\"ratio_coords\": " << instance.memory.ratio_coords_ << std::endl; + os << "\t}" << std::endl; + os << "}"; +} + } // namespace rc + +TEST_CASE_METHOD( + CSparseGlobalOrderFx, + "Sparse global order reader: rapidcheck 1d", + "[sparse-global-order]") { + rc::prop("rapidcheck arbitrary 1d", [this](FxRun1D instance) { + run_1d(instance); + }); +} From bfe5de88f347a9f913d79aa772c0f0d0241e3d33 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 13 Dec 2024 08:15:38 -0500 Subject: [PATCH 050/228] Clean CMakeLists.txt --- test/CMakeLists.txt | 4 ---- 1 file changed, 4 deletions(-) diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 6976fc2a36e..c0399cc31ae 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -353,10 +353,6 @@ find_library( NAMES rapidcheck ) -#if (LIBRAPIDCHECK) -# add_subdirectory(${LIBRAPIDCHECK}) -#endif() - add_test( NAME "tiledb_unit" COMMAND tiledb_unit --durations=yes From 25f3f01a9be79cb89403fcc807aba7aabce5a485 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 13 Dec 2024 08:15:53 -0500 Subject: [PATCH 051/228] Fix allow_dups in fragment skew, interleave tests --- test/src/unit-sparse-global-order-reader.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 2044f0a4e88..ad75618d9d4 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -885,6 +885,7 @@ TEST_CASE_METHOD( instance.num_user_cells = num_user_cells; instance.array.extent = extent; + instance.array.allow_dups = true; instance.memory.total_budget_ = "20000"; instance.memory.ratio_array_data_ = "0.5"; @@ -957,6 +958,7 @@ TEST_CASE_METHOD( instance.num_user_cells = num_user_cells; instance.memory.total_budget_ = "20000"; instance.memory.ratio_array_data_ = "0.5"; + instance.array.allow_dups = true; run_1d(instance); }; From f5bde2db6d5d6af7fc7867c51f425c914da24319 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 16 Dec 2024 16:28:37 -0500 Subject: [PATCH 052/228] parallel merge throws if status is not ok --- tiledb/common/algorithm/parallel_merge.cc | 2 +- tiledb/common/algorithm/parallel_merge.h | 9 ++++++++- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/tiledb/common/algorithm/parallel_merge.cc b/tiledb/common/algorithm/parallel_merge.cc index 4ca7071a069..31ab5247e6f 100644 --- a/tiledb/common/algorithm/parallel_merge.cc +++ b/tiledb/common/algorithm/parallel_merge.cc @@ -51,7 +51,7 @@ ParallelMergeFuture::ParallelMergeFuture( std::optional ParallelMergeFuture::await() { auto maybe_task = merge_tasks_.pop(); if (maybe_task.has_value()) { - maybe_task->wait(); + throw_if_not_ok(maybe_task->wait()); return merge_bounds_[merge_cursor_++].output_end(); } else { return std::nullopt; diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h index dec2a517ce7..2bad4e9b94a 100644 --- a/tiledb/common/algorithm/parallel_merge.h +++ b/tiledb/common/algorithm/parallel_merge.h @@ -100,12 +100,19 @@ struct ParallelMergeFuture { /** * Wait for more data to finish merging. * - * @return the bound in the output buffer up to which the merge has completed + * @return The bound in the output buffer up to which the merge has completed + * @throws If a task finished with error status. + * If this happens then this future is left in an invalid state + * and should not be used. */ std::optional await(); /** * Wait for all data to finish merging. + * + * @throws If a task finished with error status. + * If this happens then this future is left in an invalid state + * and should not be used. */ void block(); From 5b44b63e690cdcef7094b4fc9cde98fbceea7ef5 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 17 Dec 2024 12:18:16 -0500 Subject: [PATCH 053/228] LIBRAPIDCHECK REQUIRED --- test/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 8fe5a298cbe..7297cb54a93 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -353,6 +353,7 @@ endif() find_library( LIBRAPIDCHECK NAMES rapidcheck + REQUIRED ) add_test( From e486fcd236fdfe4a66ec6d1dd603cb7f583461f3 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 17 Dec 2024 12:19:16 -0500 Subject: [PATCH 054/228] Add harness for running comparison off/on against any array URI --- test/src/unit-sparse-global-order-reader.cc | 188 +++++++++++++++++++- 1 file changed, 183 insertions(+), 5 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index ad75618d9d4..6c1a60479ae 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -36,6 +36,7 @@ #include "tiledb/sm/c_api/tiledb_struct_def.h" #include "tiledb/sm/cpp_api/tiledb" #include "tiledb/sm/query/readers/sparse_global_order_reader.h" +#include "tiledb/sm/stats/duration_instrument.h" #ifdef _WIN32 #include "tiledb/sm/filesystem/win.h" @@ -1831,6 +1832,8 @@ TEST_CASE_METHOD( template void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { + RCCATCH_REQUIRE(instance.num_user_cells > 0); + reset_config(); memory_ = instance.memory; @@ -2014,10 +2017,14 @@ struct Arbitrary { [](auto fragments) { return !fragments.empty(); })); }); + auto num_user_cells = gen::inRange(1, 8 * 1024 * 1024); + return gen::apply( [](std::pair, std::vector> - fragments) { + fragments, + int num_user_cells) { FxRun1D instance; + instance.num_user_cells = num_user_cells; std::tuple dimension; std::tie(dimension, instance.fragments) = fragments; @@ -2028,7 +2035,8 @@ struct Arbitrary { instance.array.extent) = dimension; return instance; }, - fragments); + fragments, + num_user_cells); } }; @@ -2083,7 +2091,177 @@ TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: rapidcheck 1d", "[sparse-global-order]") { - rc::prop("rapidcheck arbitrary 1d", [this](FxRun1D instance) { - run_1d(instance); - }); + SECTION("Shrink") { + FxFragment1D fragment; + fragment.coords = std::vector{0}; + fragment.atts = std::vector{0}; + + FxRun1D instance; + instance.fragments.push_back(fragment); + instance.array.domain[0] = 0; + instance.array.domain[1] = 0; + instance.array.extent = 1; + } + + SECTION("Rapidcheck") { + rc::prop("rapidcheck arbitrary 1d", [this](FxRun1D instance) { + run_1d(instance); + }); + } +} + +struct TimeKeeper { + std::map> durations; + + tiledb::sm::stats::DurationInstrument start_timer( + const std::string& stat) { + return tiledb::sm::stats::DurationInstrument(*this, stat); + } + + void report_duration( + const std::string& stat, const std::chrono::duration duration) { + durations[stat].push_back(duration.count()); + } +}; + +/** + * Runs sparse global order reader on a 2D array which is + * highly representative of SOMA workloads + */ +TEST_CASE_METHOD( + CSparseGlobalOrderFx, + "Sparse global order reader: jkerl SOMA", + "[sparse-global-order]") { + using Asserter = tiledb::test::Catch; + + const char* array_uri = + "s3://tiledb-johnkerl/s/v/tabula-sapiens-immune/ms/RNA/X/data"; + + memory_.total_budget_ = std::to_string(1024 * 1024 * 1024); + memory_.ratio_tile_ranges_ = "0.01"; + update_config(); + + const uint64_t num_user_cells = 1024 * 1024; + + std::vector offdim0(num_user_cells); + std::vector offdim1(num_user_cells); + std::vector offdata(num_user_cells); + std::vector ondim0(num_user_cells); + std::vector ondim1(num_user_cells); + std::vector ondata(num_user_cells); + + // Open array for reading. + CApiArray array(ctx_, array_uri, TILEDB_READ); + + // Create query which does NOT do merge + tiledb_query_t* off_query; + auto rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &off_query); + RCCATCH_REQUIRE("" == error_if_any(rc)); + rc = tiledb_query_set_layout(ctx_, off_query, TILEDB_GLOBAL_ORDER); + RCCATCH_REQUIRE("" == error_if_any(rc)); + + // Create query which DOES do merge + tiledb_query_t* on_query; + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &on_query); + RCCATCH_REQUIRE("" == error_if_any(rc)); + rc = tiledb_query_set_layout(ctx_, on_query, TILEDB_GLOBAL_ORDER); + RCCATCH_REQUIRE("" == error_if_any(rc)); + { + tiledb_config_t* qconfig; + tiledb_error_t* error = nullptr; + RCCATCH_REQUIRE(tiledb_config_alloc(&qconfig, &error) == TILEDB_OK); + RCCATCH_REQUIRE(error == nullptr); + rc = tiledb_config_set( + qconfig, + "sm.query.sparse_global_order.preprocess_tile_merge", + "true", + &error); + RCCATCH_REQUIRE("" == error_if_any(rc)); + rc = tiledb_query_set_config(ctx_, on_query, qconfig); + RCCATCH_REQUIRE("" == error_if_any(rc)); + tiledb_config_free(&qconfig); + } + + TimeKeeper time_keeper; + + // helper to do basic checks on both + auto do_submit = [&](auto& key, + auto& query, + auto& outdim0, + auto& outdim1, + auto& outdata) -> uint64_t { + uint64_t outdim0_size = outdim0.size() * sizeof(int64_t); + uint64_t outdim1_size = outdim1.size() * sizeof(int64_t); + uint64_t outdata_size = outdata.size() * sizeof(float); + + rc = tiledb_query_set_data_buffer( + ctx_, query, "soma_dim_0", &outdim0[0], &outdim0_size); + RCCATCH_REQUIRE("" == error_if_any(rc)); + rc = tiledb_query_set_data_buffer( + ctx_, query, "soma_dim_1", &outdim1[0], &outdim1_size); + RCCATCH_REQUIRE("" == error_if_any(rc)); + rc = tiledb_query_set_data_buffer( + ctx_, query, "soma_data", &outdata[0], &outdata_size); + RCCATCH_REQUIRE("" == error_if_any(rc)); + + { + tiledb::sm::stats::DurationInstrument qtimer = + time_keeper.start_timer(key); + rc = tiledb_query_submit(ctx_, query); + RCCATCH_REQUIRE("" == error_if_any(rc)); + } + + tiledb_query_status_t status; + rc = tiledb_query_get_status(ctx_, query, &status); + RCCATCH_REQUIRE("" == error_if_any(rc)); + + RCCATCH_REQUIRE(outdim0_size % sizeof(int64_t) == 0); + RCCATCH_REQUIRE(outdim1_size % sizeof(int64_t) == 0); + RCCATCH_REQUIRE(outdata_size % sizeof(float) == 0); + + const uint64_t num_dim0 = outdim0_size / sizeof(int64_t); + const uint64_t num_dim1 = outdim1_size / sizeof(int64_t); + const uint64_t num_data = outdata_size / sizeof(float); + + RCCATCH_REQUIRE(num_dim0 == num_dim1); + RCCATCH_REQUIRE(num_dim0 == num_data); + + if (num_dim0 < outdim0.size()) { + RCCATCH_REQUIRE(status == TILEDB_COMPLETED); + } + + return num_dim0; + }; + + while (true) { + const uint64_t off_num_cells = + do_submit("off", off_query, offdim0, offdim1, offdata); + const uint64_t on_num_cells = + do_submit("on", on_query, ondim0, ondim1, ondata); + + RCCATCH_REQUIRE(off_num_cells == on_num_cells); + + offdim0.resize(off_num_cells); + offdim1.resize(off_num_cells); + offdata.resize(off_num_cells); + ondim0.resize(on_num_cells); + ondim1.resize(on_num_cells); + ondata.resize(on_num_cells); + + RCCATCH_REQUIRE(offdim0 == ondim0); + RCCATCH_REQUIRE(offdim1 == ondim1); + RCCATCH_REQUIRE(offdata == ondata); + + offdim0.resize(num_user_cells); + offdim1.resize(num_user_cells); + offdata.resize(num_user_cells); + ondim0.resize(num_user_cells); + ondim1.resize(num_user_cells); + ondata.resize(num_user_cells); + + if (off_num_cells < num_user_cells) { + break; + } + } } + From 263c23f062f32dc3f67b995c1855401b9a12e8f1 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 17 Dec 2024 15:35:31 -0500 Subject: [PATCH 055/228] Add subarray to fragment skew test --- test/src/unit-sparse-global-order-reader.cc | 111 ++++++++++++++++++-- 1 file changed, 102 insertions(+), 9 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 6c1a60479ae..7a5c3a265eb 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -51,6 +51,11 @@ using namespace tiledb; using namespace tiledb::test; +namespace rc { +Gen>> make_subarray_1d( + int domain_lower, int domain_upper); +} + /* ********************************* */ /* STRUCT DEFINITION */ /* ********************************* */ @@ -107,8 +112,25 @@ struct FxRun1D { uint64_t num_user_cells; std::vector fragments; + // NB: for now this always has length 1, global order query does not + // support multi-range subarray + std::vector> subarray; + DefaultArray1DConfig array; MemoryBudget memory; + + bool accept_coord(int coord) const { + if (subarray.empty()) { + return true; + } else { + for (const auto& range : subarray) { + if (range.first <= coord && coord <= range.second) { + return true; + } + } + return false; + } + } }; /** @@ -225,6 +247,12 @@ struct CSparseGlobalOrderFx { ~CSparseGlobalOrderFx(); }; +#define TRY(thing) \ + do { \ + auto rc = (thing); \ + RCCATCH_REQUIRE("" == error_if_any(rc)); \ + } while (0) + template std::string CSparseGlobalOrderFx::error_if_any(CAPIReturn apirc) const { if (apirc == TILEDB_OK) { @@ -858,7 +886,11 @@ TEST_CASE_METHOD( "Sparse global order reader: fragment skew", "[sparse-global-order]") { auto doit = [this]( - size_t fragment_size, size_t num_user_cells, int extent) { + size_t fragment_size, + size_t num_user_cells, + int extent, + const std::vector>& subarray = + std::vector>()) { // Write a fragment F0 with unique coordinates struct FxFragment1D fragment0; fragment0.coords.resize(fragment_size); @@ -891,6 +923,8 @@ TEST_CASE_METHOD( instance.memory.total_budget_ = "20000"; instance.memory.ratio_array_data_ = "0.5"; + instance.subarray = subarray; + run_1d(instance); }; @@ -903,8 +937,9 @@ TEST_CASE_METHOD( const size_t fragment_size = *rc::gen::inRange(2, 200); const size_t num_user_cells = *rc::gen::inRange(1, 1024); const int extent = *rc::gen::inRange(1, 200); + const auto subarray = *rc::make_subarray_1d(1, 200); doit.operator()( - fragment_size, num_user_cells, extent); + fragment_size, num_user_cells, extent, subarray); }); } } @@ -1859,13 +1894,27 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { std::vector expectcoords; std::vector expectatts; for (const auto& fragment : instance.fragments) { - expectcoords.reserve(expectcoords.size() + fragment.coords.size()); - expectatts.reserve(expectatts.size() + fragment.atts.size()); - - expectcoords.insert( - expectcoords.end(), fragment.coords.begin(), fragment.coords.end()); - expectatts.insert( - expectatts.end(), fragment.atts.begin(), fragment.atts.end()); + if (instance.subarray.empty()) { + expectcoords.reserve(expectcoords.size() + fragment.coords.size()); + expectatts.reserve(expectatts.size() + fragment.atts.size()); + expectcoords.insert( + expectcoords.end(), fragment.coords.begin(), fragment.coords.end()); + expectatts.insert( + expectatts.end(), fragment.atts.begin(), fragment.atts.end()); + } else { + std::vector passing_idxs; + for (uint64_t i = 0; i < fragment.coords.size(); i++) { + if (instance.accept_coord(fragment.coords[i])) { + passing_idxs.push_back(i); + } + } + expectcoords.reserve(expectcoords.size() + passing_idxs.size()); + expectatts.reserve(expectatts.size() + passing_idxs.size()); + for (const uint64_t i : passing_idxs) { + expectcoords.push_back(fragment.coords[i]); + expectatts.push_back(fragment.atts[i]); + } + } } // sort for naive comparison @@ -1898,6 +1947,17 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); RCCATCH_REQUIRE(rc == TILEDB_OK); + if (!instance.subarray.empty()) { + tiledb_subarray_t* subarray; + TRY(tiledb_subarray_alloc(ctx_, array, &subarray)); + for (const auto& range : instance.subarray) { + TRY(tiledb_subarray_add_range( + ctx_, subarray, 0, &range.first, &range.second, nullptr)); + } + TRY(tiledb_query_set_subarray_t(ctx_, query, subarray)); + tiledb_subarray_free(&subarray); + } + // Prepare output buffer std::vector outcoords; std::vector outatts; @@ -1945,6 +2005,9 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { // Clean up. tiledb_query_free(&query); + outcoords.resize(outcursor); + outatts.resize(outcursor); + RCCATCH_REQUIRE(expectcoords == outcoords); // Checking attributes is more complicated because equal coords @@ -1970,6 +2033,36 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { } namespace rc { + +Gen>> make_subarray_1d( + int domain_lower, int domain_upper) { + auto point = gen::cast( + gen::inRange(int64_t(domain_lower), int64_t(domain_upper) + 1)); + + auto range = gen::apply( + [](int point1, int point2) { + return std::make_pair( + std::min(point1, point2), std::max(point1, point2)); + }, + point, + point); + + // NB: when (if) multi-range subarray is supported for global order + // (or if this is used for non-global order) + // change `num_ranges` to use the weighted element version + std::optional> num_ranges; + if (true) { + num_ranges = gen::just(1); + } else { + num_ranges = gen::weightedElement( + {{50, 1}, {25, 2}, {13, 3}, {7, 4}, {4, 5}, {1, 6}}); + } + + return gen::mapcat(*num_ranges, [range](int num_ranges) { + return gen::container>>(num_ranges, range); + }); +} + template <> struct Arbitrary { static Gen arbitrary() { From e47fc5b6fa1773ffc07c6b176bc33feaba39a7b6 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 17 Dec 2024 21:16:07 -0500 Subject: [PATCH 056/228] Remove dead SECTION --- test/src/unit-sparse-global-order-reader.cc | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 7a5c3a265eb..be34df37a86 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2184,18 +2184,6 @@ TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: rapidcheck 1d", "[sparse-global-order]") { - SECTION("Shrink") { - FxFragment1D fragment; - fragment.coords = std::vector{0}; - fragment.atts = std::vector{0}; - - FxRun1D instance; - instance.fragments.push_back(fragment); - instance.array.domain[0] = 0; - instance.array.domain[1] = 0; - instance.array.extent = 1; - } - SECTION("Rapidcheck") { rc::prop("rapidcheck arbitrary 1d", [this](FxRun1D instance) { run_1d(instance); From e39bbbc7c8a4750c31052c5f9b23d31613a3469d Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 17 Dec 2024 21:29:17 -0500 Subject: [PATCH 057/228] Add signal test for supporting multi-range subarray for global order --- test/src/unit-sparse-global-order-reader.cc | 38 +++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index be34df37a86..8218a76a9b8 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2191,6 +2191,44 @@ TEST_CASE_METHOD( } } +/** + * This test will fail if multi-range subarrays become supported + * for global order. + * When that happens please update all the related `NB` comments + * (and also feel free to remove this at that time). + */ +TEST_CASE_METHOD( + CSparseGlobalOrderFx, + "Sparse global order reader: multi-range subarray signal", + "[sparse-global-order]") { + FxFragment1D fragment0; + fragment0.coords.push_back(1); + fragment0.atts.push_back(1); + + FxRun1D instance; + instance.fragments.push_back(fragment0); + instance.subarray.push_back({1, 1}); + instance.subarray.push_back({3, 3}); + + // NB: `Rapidcheck` just throws a normal exception, + // we are not actually in a rapidcheck context. + REQUIRE_THROWS(run_1d(instance)); + + tiledb_error_t* error = NULL; + auto rc = tiledb_ctx_get_last_error(ctx_, &error); + REQUIRE(rc == TILEDB_OK); + REQUIRE(error != nullptr); + + const char* msg; + rc = tiledb_error_message(error, &msg); + REQUIRE(rc == TILEDB_OK); + + REQUIRE( + std::string(msg).find( + "Multi-range reads are not supported on a global order query") != + std::string::npos); +} + struct TimeKeeper { std::map> durations; From b3c136ab622802510ecaf3cf8622409b47b2b1e4 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 17 Dec 2024 21:34:18 -0500 Subject: [PATCH 058/228] Improve populate_relevant_tiles --- .../readers/sparse_global_order_reader.cc | 21 ++++++++----------- .../query/readers/sparse_index_reader_base.h | 17 --------------- 2 files changed, 9 insertions(+), 29 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 67593cef492..cc876b1aeb9 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -420,21 +420,18 @@ void SparseGlobalOrderReader< auto populate_relevant_tiles = [&](unsigned rf) { const unsigned f = relevant_fragments[rf]; - std::vector tile_is_relevant( - fragment_metadata_[f]->tile_num(), false); + const auto& fragment_tile_ranges = tmp_read_state_.tile_ranges(f); - for (uint64_t t = 0; t < fragment_metadata_[f]->tile_num(); t++) { - if (tmp_read_state_.contains_tile(f, t)) { - tile_is_relevant[t] = true; - } + uint64_t num_qualifying_tiles = 0; + for (const auto& tile_range : fragment_tile_ranges) { + num_qualifying_tiles += 1 + tile_range.second - tile_range.first; } + fragment_result_tiles[f].reserve(num_qualifying_tiles); - const uint64_t num_relevant_tiles = - std::count(tile_is_relevant.begin(), tile_is_relevant.end(), true); - - fragment_result_tiles[f].reserve(num_relevant_tiles); - for (uint64_t t = 0; t < tile_is_relevant.size(); t++) { - if (tile_is_relevant[t]) { + for (auto tile_range = fragment_tile_ranges.rbegin(); + tile_range != fragment_tile_ranges.rend(); + ++tile_range) { + for (uint64_t t = tile_range->first; t <= tile_range->second; t++) { fragment_result_tiles[f].push_back( ResultTileId{.fragment_idx_ = f, .tile_idx_ = t}); } diff --git a/tiledb/sm/query/readers/sparse_index_reader_base.h b/tiledb/sm/query/readers/sparse_index_reader_base.h index 9b5c540fc8b..2a7553a70ed 100644 --- a/tiledb/sm/query/readers/sparse_index_reader_base.h +++ b/tiledb/sm/query/readers/sparse_index_reader_base.h @@ -431,23 +431,6 @@ class SparseIndexReaderBase : public ReaderBase { return tile_ranges_[f]; } - /** - * @param f Fragment index - * @param t Tile index - * @return true if the tile is included in the subarray, false otherwise - */ - bool contains_tile(unsigned f, uint64_t t) const { - // TODO: the comment claims this is reverse sorted, this can probably - // exploit that? Looks like the previous implementation did do so, - // iterating in reverse order and then popping off the back - for (const auto& tile_range : tile_ranges_[f]) { - if (tile_range.first <= t && t <= tile_range.second) { - return true; - } - } - return false; - } - /** * Return if all tiles are loaded for a fragment. * From e13e65c95a9b6be5d00e724d75f62b86a78fe133 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 17 Dec 2024 21:44:14 -0500 Subject: [PATCH 059/228] make format --- test/src/unit-sparse-global-order-reader.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 8218a76a9b8..22a22f52746 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2383,4 +2383,3 @@ TEST_CASE_METHOD( } } } - From 7d9443adb62f9f9f02f6dfc673067f97dc57407b Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 18 Dec 2024 11:27:03 -0500 Subject: [PATCH 060/228] TimeKeeper::dump_durations --- test/src/unit-sparse-global-order-reader.cc | 26 ++++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 22a22f52746..27559cbc9b9 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -46,6 +46,8 @@ #include #include + +#include #include using namespace tiledb; @@ -2241,6 +2243,26 @@ struct TimeKeeper { const std::string& stat, const std::chrono::duration duration) { durations[stat].push_back(duration.count()); } + + void dump_durations(const char* path) const { + std::ofstream dump(path); + + for (const auto& stat : durations) { + dump << stat.first << " = ["; + + bool is_first = true; + for (const auto& duration : stat.second) { + if (!is_first) { + dump << ", "; + } else { + is_first = false; + } + dump << duration; + } + + dump << "]" << std::endl << std::endl; + } + } }; /** @@ -2249,7 +2271,7 @@ struct TimeKeeper { */ TEST_CASE_METHOD( CSparseGlobalOrderFx, - "Sparse global order reader: jkerl SOMA", + "Sparse global order reader: benchmark compare", "[sparse-global-order]") { using Asserter = tiledb::test::Catch; @@ -2382,4 +2404,6 @@ TEST_CASE_METHOD( break; } } + + time_keeper.dump_durations("/tmp/time_keeper.out"); } From 34603222602f2e0ee91a0af853b5e64437baf89a Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 18 Dec 2024 15:18:22 -0500 Subject: [PATCH 061/228] Genericize rapidcheck generators for domain,coord,fragment,etc --- test/src/unit-sparse-global-order-reader.cc | 140 ++++----- test/support/rapidcheck/array.h | 321 ++++++++++++++++++++ test/support/tdb_rapidcheck.h | 64 ++-- 3 files changed, 406 insertions(+), 119 deletions(-) create mode 100644 test/support/rapidcheck/array.h diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 27559cbc9b9..27c29c9104b 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -30,6 +30,7 @@ * Tests for the sparse global order reader. */ +#include "test/support/rapidcheck/array.h" #include "test/support/src/helpers.h" #include "test/support/src/vfs_helpers.h" #include "tiledb/sm/c_api/tiledb.h" @@ -54,8 +55,8 @@ using namespace tiledb; using namespace tiledb::test; namespace rc { -Gen>> make_subarray_1d( - int domain_lower, int domain_upper); +Gen>> make_subarray_1d( + const tdbrc::Domain& domain); } /* ********************************* */ @@ -90,14 +91,14 @@ struct MemoryBudget { */ struct DefaultArray1DConfig { bool allow_dups; - int domain[2]; - int extent; + + tdbrc::Dimension dimension; DefaultArray1DConfig() - : allow_dups(false) - , extent(2) { - domain[0] = 1; - domain[1] = 200; + : allow_dups(false) { + dimension.domain.lower_bound = 1; + dimension.domain.upper_bound = 200; + dimension.extent = 2; } DefaultArray1DConfig with_allow_dups(bool allow_dups) const { @@ -116,7 +117,7 @@ struct FxRun1D { // NB: for now this always has length 1, global order query does not // support multi-range subarray - std::vector> subarray; + std::vector> subarray; DefaultArray1DConfig array; MemoryBudget memory; @@ -126,7 +127,7 @@ struct FxRun1D { return true; } else { for (const auto& range : subarray) { - if (range.first <= coord && coord <= range.second) { + if (range.contains(coord)) { return true; } } @@ -192,13 +193,13 @@ struct CSparseGlobalOrderFx { MemoryBudget memory_; - template + template void create_default_array_1d( const DefaultArray1DConfig& config = DefaultArray1DConfig()); void create_default_array_1d_strings(bool allow_dups = false); - template + template void write_1d_fragment( int* coords, uint64_t* coords_size, int* data, uint64_t* data_size); @@ -378,8 +379,8 @@ void CSparseGlobalOrderFx::create_default_array_1d( TILEDB_SPARSE, {"d"}, {TILEDB_INT32}, - std::vector{(void*)(&config.domain[0])}, - std::vector{(void*)(&config.extent)}, + std::vector{(void*)(&config.dimension.domain.lower_bound)}, + std::vector{(void*)(&config.dimension.extent)}, {"a"}, {TILEDB_INT32}, {1}, @@ -891,8 +892,8 @@ TEST_CASE_METHOD( size_t fragment_size, size_t num_user_cells, int extent, - const std::vector>& subarray = - std::vector>()) { + const std::vector>& subarray = + std::vector>()) { // Write a fragment F0 with unique coordinates struct FxFragment1D fragment0; fragment0.coords.resize(fragment_size); @@ -919,7 +920,7 @@ TEST_CASE_METHOD( instance.fragments.push_back(fragment1); instance.num_user_cells = num_user_cells; - instance.array.extent = extent; + instance.array.dimension.extent = extent; instance.array.allow_dups = true; instance.memory.total_budget_ = "20000"; @@ -931,7 +932,7 @@ TEST_CASE_METHOD( }; SECTION("Example") { - doit.operator()(200, 8, 2); + doit.operator()(200, 8, 2); } SECTION("Rapidcheck") { @@ -939,8 +940,8 @@ TEST_CASE_METHOD( const size_t fragment_size = *rc::gen::inRange(2, 200); const size_t num_user_cells = *rc::gen::inRange(1, 1024); const int extent = *rc::gen::inRange(1, 200); - const auto subarray = *rc::make_subarray_1d(1, 200); - doit.operator()( + const auto subarray = *rc::make_subarray_1d(tdbrc::Domain(1, 200)); + doit.operator()( fragment_size, num_user_cells, extent, subarray); }); } @@ -1002,14 +1003,15 @@ TEST_CASE_METHOD( }; SECTION("Example") { - doit.operator()(196, 8); + doit.operator()(196, 8); } SECTION("Rapidcheck") { rc::prop("rapidcheck fragment interleave", [doit]() { const size_t fragment_size = *rc::gen::inRange(2, 196); const size_t num_user_cells = *rc::gen::inRange(1, 1024); - doit.operator()(fragment_size, num_user_cells); + doit.operator()( + fragment_size, num_user_cells); }); } @@ -1954,7 +1956,7 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { TRY(tiledb_subarray_alloc(ctx_, array, &subarray)); for (const auto& range : instance.subarray) { TRY(tiledb_subarray_add_range( - ctx_, subarray, 0, &range.first, &range.second, nullptr)); + ctx_, subarray, 0, &range.lower_bound, &range.upper_bound, nullptr)); } TRY(tiledb_query_set_subarray_t(ctx_, query, subarray)); tiledb_subarray_free(&subarray); @@ -2036,19 +2038,8 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { namespace rc { -Gen>> make_subarray_1d( - int domain_lower, int domain_upper) { - auto point = gen::cast( - gen::inRange(int64_t(domain_lower), int64_t(domain_upper) + 1)); - - auto range = gen::apply( - [](int point1, int point2) { - return std::make_pair( - std::min(point1, point2), std::max(point1, point2)); - }, - point, - point); - +Gen>> make_subarray_1d( + const tdbrc::Domain& domain) { // NB: when (if) multi-range subarray is supported for global order // (or if this is used for non-global order) // change `num_ranges` to use the weighted element version @@ -2060,74 +2051,44 @@ Gen>> make_subarray_1d( {{50, 1}, {25, 2}, {13, 3}, {7, 4}, {4, 5}, {1, 6}}); } - return gen::mapcat(*num_ranges, [range](int num_ranges) { - return gen::container>>(num_ranges, range); + return gen::mapcat(*num_ranges, [domain](int num_ranges) { + return gen::container>>( + num_ranges, rc::make_range(domain)); }); } template <> struct Arbitrary { static Gen arbitrary() { - // NB: `gen::inRange` is exclusive at the upper end but tiledb domain is - // inclusive. So we have to use `int64_t` to avoid overflow. - auto domain = gen::mapcat(gen::arbitrary(), [](int lb) { - auto ub_limit = int64_t(std::numeric_limits::max()) + 1; - return gen::pair( - gen::just(lb), gen::cast(gen::inRange(int64_t(lb), ub_limit))); - }); - - auto dimension = gen::mapcat(domain, [](std::pair domain) { - auto extent_lower_bound = 1; - auto extent_upper_bound = std::min( - 1024 * 16, int(int64_t(domain.second) - int64_t(domain.first) + 1)); - auto extent = gen::inRange(extent_lower_bound, extent_upper_bound + 1); - return gen::tuple( - gen::just(domain.first), gen::just(domain.second), extent); - }); + auto dimension = gen::arbitrary>(); auto fragments = - gen::mapcat(dimension, [](std::tuple dimension) { - int coord_lb, coord_ub; - std::tie(coord_lb, coord_ub, std::ignore) = dimension; - auto coord = gen::cast( - gen::inRange(int64_t(coord_lb), int64_t(coord_ub) + 1)); - - auto coords = gen::suchThat( - gen::container>(coord), - [](std::vector coords) { return !coords.empty(); }); - - auto fragment = gen::mapcat(coords, [](std::vector coords) { - return gen::map( - gen::container>( - coords.size(), gen::arbitrary()), - [coords](std::vector atts) { - return FxFragment1D{.coords = coords, .atts = atts}; - }); - }); + gen::mapcat(dimension, [](tdbrc::Dimension dimension) { + auto fragment = gen::map( + rc::make_fragment_1d(dimension.domain), + [](tdbrc::Fragment1D fragment) { + return FxFragment1D{ + .coords = fragment.dim, .atts = std::get<0>(fragment.atts)}; + }); return gen::pair( gen::just(dimension), - gen::suchThat( - gen::container>(fragment), - [](auto fragments) { return !fragments.empty(); })); + gen::nonEmpty( + gen::container>(fragment))); }); auto num_user_cells = gen::inRange(1, 8 * 1024 * 1024); return gen::apply( - [](std::pair, std::vector> + [](std::pair, std::vector> fragments, int num_user_cells) { FxRun1D instance; - instance.num_user_cells = num_user_cells; + std::tie(instance.array.dimension, instance.fragments) = fragments; - std::tuple dimension; - std::tie(dimension, instance.fragments) = fragments; + instance.num_user_cells = num_user_cells; instance.array.allow_dups = true; - std::tie( - instance.array.domain[0], - instance.array.domain[1], - instance.array.extent) = dimension; + return instance; }, fragments, @@ -2164,9 +2125,10 @@ void show(const FxRun1D& instance, std::ostream& os) { os << "\t\"num_user_cells\": " << instance.num_user_cells << std::endl; os << "\t\"array\": {" << std::endl; os << "\t\t\"allow_dups\": " << instance.array.allow_dups << std::endl; - os << "\t\t\"domain\": [" << instance.array.domain[0] << ", " - << instance.array.domain[1] << "]," << std::endl; - os << "\t\t\"extent\": " << instance.array.extent << std::endl; + os << "\t\t\"domain\": [" << instance.array.dimension.domain.lower_bound + << ", " << instance.array.dimension.domain.upper_bound << "]," + << std::endl; + os << "\t\t\"extent\": " << instance.array.dimension.extent << std::endl; os << "\t}," << std::endl; os << "\t\"memory\": {" << std::endl; os << "\t\t\"total_budget\": " << instance.memory.total_budget_ << ", " @@ -2188,7 +2150,7 @@ TEST_CASE_METHOD( "[sparse-global-order]") { SECTION("Rapidcheck") { rc::prop("rapidcheck arbitrary 1d", [this](FxRun1D instance) { - run_1d(instance); + run_1d(instance); }); } } @@ -2214,7 +2176,7 @@ TEST_CASE_METHOD( // NB: `Rapidcheck` just throws a normal exception, // we are not actually in a rapidcheck context. - REQUIRE_THROWS(run_1d(instance)); + REQUIRE_THROWS(run_1d(instance)); tiledb_error_t* error = NULL; auto rc = tiledb_ctx_get_last_error(ctx_, &error); @@ -2273,7 +2235,7 @@ TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: benchmark compare", "[sparse-global-order]") { - using Asserter = tiledb::test::Catch; + using Asserter = tiledb::test::AsserterCatch; const char* array_uri = "s3://tiledb-johnkerl/s/v/tabula-sapiens-immune/ms/RNA/X/data"; diff --git a/test/support/rapidcheck/array.h b/test/support/rapidcheck/array.h new file mode 100644 index 00000000000..78972ad6503 --- /dev/null +++ b/test/support/rapidcheck/array.h @@ -0,0 +1,321 @@ +/** + * @file test/support/rapidcheck/array.h + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2022-2024 TileDB, 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. + * + * @section DESCRIPTION + * + * This file defines structures and rapidcheck generators which + * can be commonly useful for writing rapidcheck properties + * about tiledb array. + */ + +#ifndef TILEDB_RAPIDCHECK_ARRAY_H +#define TILEDB_RAPIDCHECK_ARRAY_H + +#include + +#include +#include +#include + +namespace tiledb::test::tdbrc { + +/** + * Describes types which can be used for rapidcheck-generated dimensions. + */ +template +concept DimensionType = requires(const D& coord) { + typename ::rc::Arbitrary; + typename std::is_signed; + { coord < coord } -> std::same_as; + { D(int64_t(coord)) } -> std::same_as; +}; + +/** + * Describes types which can be used for rapidcheck-generated attributes. + */ +template +concept AttributeType = + requires(const T& coord) { typename ::rc::Arbitrary; }; + +/** + * A generic, statically-typed range which is inclusive on both ends. + */ +template +struct Domain { + D lower_bound; + D upper_bound; + + Domain() { + } + + Domain(D d1, D d2) + : lower_bound(std::min(d1, d2)) + , upper_bound(std::max(d1, d2)) { + } + + bool contains(D point) const { + return lower_bound <= point && point <= upper_bound; + } +}; + +/** + * A description of a dimension as it pertains to its datatype. + */ +template +struct Dimension { + Domain domain; + D extent; +}; + +/** + * Data for a one-dimensional array + */ +template +struct Fragment1D { + std::vector dim; + std::tuple...> atts; +}; + +/** + * Data for a two-dimensional array + */ +template +struct Fragment2D { + std::vector d1; + std::vector d2; + std::tuple...> atts; +}; + +} // namespace tiledb::test::tdbrc + +namespace stdx { + +/** + * @return the transposition of row-oriented tuples into column-oriented tuples + */ +template +std::tuple...> transpose(std::vector> rows) { + std::tuple...> cols; + + std::apply( + [&](std::vector&... col) { (col.reserve(rows.size()), ...); }, cols); + + for (size_t i = 0; i < rows.size(); i++) { + std::apply( + [&](std::vector&... col) { + std::apply([&](Ts... cell) { (col.push_back(cell), ...); }, rows[i]); + }, + cols); + } + + return cols; +} + +} // namespace stdx + +namespace rc { + +using namespace tiledb::test::tdbrc; + +template +struct Arbitrary> { + static Gen> arbitrary() { + // NB: `gen::inRange` is exclusive at the upper end but tiledb domain is + // inclusive. So we have to use `int64_t` to avoid overflow. + auto bounds = gen::mapcat(gen::arbitrary(), [](D lb) { + if (std::is_same::value) { + return gen::pair( + gen::just(lb), gen::inRange(lb, std::numeric_limits::max())); + } else if (std::is_same::value) { + return gen::pair( + gen::just(lb), gen::inRange(lb, std::numeric_limits::max())); + } else { + auto ub_limit = int64_t(std::numeric_limits::max()) + 1; + return gen::pair( + gen::just(lb), gen::cast(gen::inRange(int64_t(lb), ub_limit))); + } + }); + + return gen::map(bounds, [](std::pair bounds) { + return Domain(bounds.first, bounds.second); + }); + } +}; + +template +Gen make_extent(const Domain& domain) { + // upper bound on all possible extents to avoid unreasonably + // huge tile sizes + static constexpr D extent_limit = static_cast( + std::is_signed::value ? + std::min( + static_cast(std::numeric_limits::max()), + static_cast(1024 * 16)) : + std::min( + static_cast(std::numeric_limits::max()), + static_cast(1024 * 16))); + + // NB: `gen::inRange` is exclusive at the upper end but tiledb domain is + // inclusive. So we have to be careful to avoid overflow. + + D extent_lower_bound = 1; + D extent_upper_bound; + if (domain.lower_bound + domain.upper_bound + 1 < domain.lower_bound) { + // overflow + extent_upper_bound = extent_limit; + } else { + extent_upper_bound = + std::min(extent_limit, domain.lower_bound + domain.upper_bound + 1); + } + + return gen::inRange(extent_lower_bound, extent_upper_bound + 1); +} + +template +struct Arbitrary> { + static Gen> arbitrary() { + auto tup = gen::mapcat(gen::arbitrary>(), [](Domain domain) { + return gen::pair(gen::just(domain), make_extent(domain)); + }); + + return gen::map(tup, [](std::pair, D> tup) { + return Dimension{.domain = tup.first, .extent = tup.second}; + }); + } +}; + +template +Gen make_coordinate(const Domain& domain) { + // `gen::inRange` does an exclusive upper bound, + // whereas the domain upper bound is inclusive. + // As a result some contortion is required to deal + // with numeric_limits. + if (std::is_signed::value) { + if (domain.upper_bound < std::numeric_limits::max()) { + return gen::cast(gen::inRange( + int64_t(domain.lower_bound), int64_t(domain.upper_bound + 1))); + } else { + return gen::inRange(domain.lower_bound, domain.upper_bound); + } + } else { + if (domain.upper_bound < std::numeric_limits::max()) { + return gen::cast(gen::inRange( + uint64_t(domain.lower_bound), uint64_t(domain.upper_bound + 1))); + } else { + return gen::inRange(domain.lower_bound, domain.upper_bound); + } + } +} + +template +Gen> make_range(const Domain& domain) { + return gen::apply( + [](D p1, D p2) { return Domain(p1, p2); }, + make_coordinate(domain), + make_coordinate(domain)); +} + +template +Gen> make_fragment_1d(const Domain& d) { + auto coord = make_coordinate(d); + + auto cell = gen::tuple(coord, gen::arbitrary()...); + + using Cell = std::tuple; + + auto cells = gen::nonEmpty(gen::container>(cell)); + + return gen::map(cells, [](std::vector cells) { + std::vector coords; + std::tuple...> atts; + + std::apply( + [&](std::vector tup_d1, auto... tup_atts) { + coords = tup_d1; + atts = std::make_tuple(tup_atts...); + }, + stdx::transpose(cells)); + + return Fragment1D{.dim = coords, .atts = atts}; + }); +} + +template +Gen> make_fragment_2d( + const Domain& d1, const Domain& d2) { + auto coord_d1 = make_coordinate(d1); + auto coord_d2 = make_coordinate(d2); + + using Cell = std::tuple; + + auto cell = gen::tuple(coord_d1, coord_d2, gen::arbitrary()...); + + auto cells = gen::nonEmpty(gen::container>(cell)); + + return gen::map(cells, [](std::vector cells) { + /* + std::vector coords_d1; + std::vector coords_d2; + std::tuple...> atts; + + coords_d1.reserve(cells.size()); + coords_d2.reserve(cells.size()); + atts.reserve(cells.size())...; + + for (uint64_t i = 0; i < cells.size(); i++) { + D1 coord_d1; + D2 coord_d2; + Att... att; + std::tie(coord_d1, coord_d2, att...) = cells[i]; + coords_d1.push_back(coord_d1); + coords_d2.push_back(coord_d2); + atts.push_back(att)...; + } + */ + + std::vector coords_d1; + std::vector coords_d2; + std::tuple...> atts; + + std::apply( + [&](std::vector tup_d1, std::vector tup_d2, auto... tup_atts) { + coords_d1 = tup_d1; + coords_d2 = tup_d2; + atts = std::make_tuple(tup_atts...); + }, + stdx::transpose(cells)); + + // std::tie(coords_d1, coords_d2, atts...) = stdx::transpose(cells); + + return Fragment2D{ + .d1 = coords_d1, .d2 = coords_d2, .atts = atts}; + }); +} + +} // namespace rc + +#endif diff --git a/test/support/tdb_rapidcheck.h b/test/support/tdb_rapidcheck.h index 615cc71ab69..b5879b9b614 100644 --- a/test/support/tdb_rapidcheck.h +++ b/test/support/tdb_rapidcheck.h @@ -5,7 +5,7 @@ * * The MIT License * - * @copyright Copyright (c) 2022-2023 TileDB, Inc. + * @copyright Copyright (c) 2022-2024 TileDB, 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 @@ -51,12 +51,12 @@ namespace tiledb::test { /** * Marker that a template is instantiated by top-level CATCH code */ -struct Catch {}; +struct AsserterCatch {}; /** * Marker that a template is instantiated by a rapidcheck property */ -struct Rapidcheck {}; +struct AsserterRapidcheck {}; } // namespace tiledb::test @@ -66,21 +66,22 @@ struct Rapidcheck {}; * or in a rapidcheck property * (e.g. a function which could be called from either) * - * Expects a type named `Asserter` to be either `Catch` or `Rapidcheck`. + * Expects a type named `Asserter` to be either `AsserterCatch` or + * `AsserterRapidcheck`. * - * This expands to REQUIRE for `Catch` and RC_ASSERT for `Rapidcheck`. - * For both type markers this will throw an exception. + * This expands to REQUIRE for `AsserterCatch` and RC_ASSERT for + * `AsserterRapidcheck`. For both type markers this will throw an exception. */ -#define RCCATCH_REQUIRE(...) \ - do { \ - static_assert( \ - std::is_same::value || \ - std::is_same::value); \ - if (std::is_same::value) { \ - REQUIRE(__VA_ARGS__); \ - } else { \ - RC_ASSERT(__VA_ARGS__); \ - } \ +#define RCCATCH_REQUIRE(...) \ + do { \ + static_assert( \ + std::is_same::value || \ + std::is_same::value); \ + if (std::is_same::value) { \ + REQUIRE(__VA_ARGS__); \ + } else { \ + RC_ASSERT(__VA_ARGS__); \ + } \ } while (0) /** @@ -89,22 +90,25 @@ struct Rapidcheck {}; * or in a rapidcheck property * (e.g. a function which could be called from either) * - * Expects a type named `Asserter` to be either `Catch` or `Rapidcheck`. + * Expects a type named `Asserter` to be either `AsserterCatch` or + * `AsserterRapidcheck`. * - * This expands to CHECK for `Catch` and RC_ASSERT for `Rapidcheck`. - * For `Catch`, this will not throw an exception - the test will continue. - * For `Rapidcheck` this will throw an exception. + * This expands to CHECK for `AsserterCatch` and RC_ASSERT for + * `AsserterRapidcheck`. For `AsserterCatch`, this will not throw an exception - + * the test will continue. For `AsserterRapidcheck` this will throw an + * exception. */ -#define RCCATCH_CHECK(...) \ - do { \ - static_assert( \ - std::is_same_type::::value || \ - std::is_same_type::::value); \ - if (std::is_same_type::::value) { \ - CHECK(__VA_ARGS__); \ - } else { \ - RC_ASSERT(__VA_ARGS__); \ - } \ +#define RCCATCH_CHECK(...) \ + do { \ + static_assert( \ + std::is_same_type::::value || \ + std::is_same_type:::: \ + value); \ + if (std::is_same_type::::value) { \ + CHECK(__VA_ARGS__); \ + } else { \ + RC_ASSERT(__VA_ARGS__); \ + } \ } while (0) #endif // TILEDB_MISC_TDB_RAPIDCHECK_H From 52ecdb3c5c0d0b4b7e827144611ba075714fc8d0 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 18 Dec 2024 17:02:01 -0500 Subject: [PATCH 062/228] Add test for merge being too wide --- test/src/unit-sparse-global-order-reader.cc | 83 ++++++++++++++++++- .../readers/sparse_global_order_reader.cc | 4 + 2 files changed, 83 insertions(+), 4 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 27c29c9104b..5c1705447f4 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -90,12 +90,14 @@ struct MemoryBudget { * Options for configuring the CSparseGlobalFx default 1D array */ struct DefaultArray1DConfig { + uint64_t capacity; bool allow_dups; tdbrc::Dimension dimension; DefaultArray1DConfig() - : allow_dups(false) { + : capacity(2) + , allow_dups(false) { dimension.domain.lower_bound = 1; dimension.domain.upper_bound = 200; dimension.extent = 2; @@ -387,7 +389,7 @@ void CSparseGlobalOrderFx::create_default_array_1d( {tiledb::test::Compressor(TILEDB_FILTER_NONE, -1)}, TILEDB_ROW_MAJOR, TILEDB_ROW_MAJOR, - 2, + config.capacity, config.allow_dups); } @@ -957,8 +959,6 @@ TEST_CASE_METHOD( * in global order the only way to ensure that we don't emit out of order * results with a naive implementation is to have *all* the tiles loaded * in one pass, which is not practical. - * - * TODO: */ TEST_CASE_METHOD( CSparseGlobalOrderFx, @@ -1022,6 +1022,81 @@ TEST_CASE_METHOD( */ } +/** + * Tests that the reader correctly returns an error if it cannot + * make progress due to being unable to make progress. + * The reader can stall if there is a point where F fragments + * fit in memory, but `F + 1` or more fragments overlap + * + * For example, suppose 2 tiles fit in memory. If the tiles are: + * [0, 1, 2, 3, 4] + * [1, 2, 3, 4, 5] + * [2, 3, 4, 5, 6] + * + * Then we will process the first two tiles first after ordering + * them on their lower bound. We cannot emit anything past "2" + * because it would be out of order with the third tile. + * + * After the first iteration, the state is + * [_, _, _, 3, 4] + * [_, _, 3, 4, 5] + * [2, 3, 4, 5, 6] + * + * We could make progress by un-loading a tile and then loading + * the third tile, but instead we will just error out because + * that's complicated. + * + * The user's recourse to that is to either: + * 1) increase memory budget; or + * 2) consolidate some fragments. + */ +TEST_CASE_METHOD( + CSparseGlobalOrderFx, + "Sparse global order reader: too wide", + "[sparse-global-order]") { + auto doit = [this]( + size_t num_fragments, + size_t fragment_size, + size_t num_user_cells, + const std::vector>& subarray = + std::vector>()) { + FxRun1D instance; + instance.array.capacity = num_fragments * 2; + instance.array.dimension.extent = num_fragments * 2; + instance.array.allow_dups = true; + instance.subarray = subarray; + + instance.memory.total_budget_ = "100000"; + instance.memory.ratio_coords_ = "0.2"; + instance.memory.ratio_array_data_ = "0.6"; + + for (size_t f = 0; f < num_fragments; f++) { + FxFragment1D fragment; + fragment.coords.resize(fragment_size); + std::iota( + fragment.coords.begin(), + fragment.coords.end(), + instance.array.dimension.domain.lower_bound + f); + + fragment.atts.resize(fragment_size); + std::iota( + fragment.atts.begin(), + fragment.atts.end(), + fragment_size * num_fragments); + + instance.fragments.push_back(fragment); + } + + instance.num_user_cells = num_user_cells; + + run_1d(instance); + }; + + SECTION("Example") { + doit.operator()(16, 100, 64); + } +} + TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: tile offsets budget exceeded", diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index cc876b1aeb9..4283fecf5aa 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -237,6 +237,10 @@ Status SparseGlobalOrderReader::dowork() { result_cell_slabs = std::move(rcs); } + if (created_tiles.empty() && result_cell_slabs.empty() && incomplete()) { + throw SparseGlobalOrderReaderException("No progress, TODO"); + } + // No more tiles to process, done. if (!result_cell_slabs.empty()) { // Copy cell slabs. From ecef2ca7a85cfaa181db7d2da2bb608a5e8b0259 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 19 Dec 2024 10:32:09 -0500 Subject: [PATCH 063/228] ParallelMergeFuture destructor, and some other methods --- tiledb/common/algorithm/parallel_merge.cc | 50 ++++++++++++++++++++++- tiledb/common/algorithm/parallel_merge.h | 12 ++++++ 2 files changed, 61 insertions(+), 1 deletion(-) diff --git a/tiledb/common/algorithm/parallel_merge.cc b/tiledb/common/algorithm/parallel_merge.cc index 31ab5247e6f..51336305f53 100644 --- a/tiledb/common/algorithm/parallel_merge.cc +++ b/tiledb/common/algorithm/parallel_merge.cc @@ -48,11 +48,59 @@ ParallelMergeFuture::ParallelMergeFuture( } } +ParallelMergeFuture::~ParallelMergeFuture() { + // make sure all threads are finished because they reference + // data which is contractually expected to outlive `this`, + // but makes no guarantee after that + while (true) { + const auto m = merge_cursor_; + try { + if (!await().has_value()) { + break; + } + } catch (...) { + // Swallow it. Yes, really. + // 1) exceptions cannot propagate out of destructors. + // 2) the tasks only throw on internal error, i.e. we wrote bad code. + // 3) the user did not wait for all the tasks to finish, so we had better + // do so else we risk undefined behavior. + // 4) the user did not wait for all the tasks to finish, ergo they don't + // care about the result, ergo they don't care if there is an error + // here. Most likely we are tearing down the stack to propagate + // a different exception anyway, we don't want to mask that up + // by signaling. + // + // If this is happening *not* due to an exception, then either: + // 1) the developer is responsible for blocking prior to destruction + // so as to correctly handle any errors + // 2) the developer is responsible for not caring about any + // results beyond what was previously consumed + } + + // however we definitely do want to avoid an infinite loop here, + // so we had better have made progress. + assert(merge_cursor_ > m); + } +} + +bool ParallelMergeFuture::finished() const { + return merge_cursor_ == merge_bounds_.size(); +} + +std::optional ParallelMergeFuture::valid_output_bound() const { + if (merge_cursor_ > 0) { + return merge_bounds_[merge_cursor_ - 1].output_end(); + } else { + return std::nullopt; + } +} + std::optional ParallelMergeFuture::await() { auto maybe_task = merge_tasks_.pop(); if (maybe_task.has_value()) { + const auto m = merge_cursor_++; throw_if_not_ok(maybe_task->wait()); - return merge_bounds_[merge_cursor_++].output_end(); + return merge_bounds_[m].output_end(); } else { return std::nullopt; } diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h index 2bad4e9b94a..69edb4ad2bf 100644 --- a/tiledb/common/algorithm/parallel_merge.h +++ b/tiledb/common/algorithm/parallel_merge.h @@ -90,6 +90,8 @@ struct ParallelMergeFuture { ParallelMergeFuture( ParallelMergeMemoryResources& memory, size_t parallel_factor); + ~ParallelMergeFuture(); + /** * @return memory resource used for parallel merge control structures */ @@ -97,6 +99,16 @@ struct ParallelMergeFuture { return memory_.control; } + /** + * @return true if the merge has completed + */ + bool finished() const; + + /** + * @return the position in the output up to which the merge has completed + */ + std::optional valid_output_bound() const; + /** * Wait for more data to finish merging. * From d12ba4188878a8be70e1169cb077b6d4097de807 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 19 Dec 2024 10:34:51 -0500 Subject: [PATCH 064/228] Do not block on whole merge to begin creating result tiles --- .../readers/sparse_global_order_reader.cc | 134 ++++++++++++++---- .../readers/sparse_global_order_reader.h | 18 ++- 2 files changed, 118 insertions(+), 34 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 4283fecf5aa..5641c1e901f 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -62,6 +62,14 @@ class SparseGlobalOrderReaderException : public StatusException { } }; +class SparseGlobalOrderReaderInternalError + : public SparseGlobalOrderReaderException { + public: + explicit SparseGlobalOrderReaderInternalError(const std::string& message) + : SparseGlobalOrderReaderException("Internal error: " + message) { + } +}; + /** * View into NDRange for using the range start / lower bound in comparisons. */ @@ -77,6 +85,37 @@ struct RangeLowerBound { } }; +/** + * Encapsulates the input to the preprocess tile merge, and the + * merge output future for polling. + * + * It is necessary to + * Holds + */ +struct PreprocessTileMergeFuture { + /** merge configuration, looks unused but must out-live the merge future */ + algorithm::ParallelMergeOptions merge_options_; + + /** merge input, looks unused but must out-live the merge future */ + std::vector> fragment_result_tiles_; + + std::vector> fragment_result_tile_spans_; + + /** comparator, looks unused but must out-live the merge future */ + std::shared_ptr cmp_; + + /** the merge future */ + std::optional> merge_; + + std::optional await() { + auto ret = merge_.value()->await(); + if (merge_.value()->finished()) { + fragment_result_tiles_.clear(); + } + return ret; + } +}; + /* ****************************** */ /* CONSTRUCTORS */ /* ****************************** */ @@ -167,9 +206,11 @@ Status SparseGlobalOrderReader::dowork() { // Determine result tile order // (this happens after load_initial_data which identifies which tiles pass // subarray) + std::optional preprocess_future; if (preprocess_tile_order_.enabled_ && preprocess_tile_order_.tiles_.empty()) { - preprocess_compute_result_tile_order(); + preprocess_future = PreprocessTileMergeFuture(); + preprocess_compute_result_tile_order(preprocess_future.value()); } purge_deletes_consolidation_ = !deletes_consolidation_no_purge_ && @@ -192,7 +233,7 @@ Status SparseGlobalOrderReader::dowork() { stats_->add_counter("internal_loop_num", 1); // Create the result tiles we are going to process. - auto created_tiles = create_result_tiles(result_tiles); + auto created_tiles = create_result_tiles(result_tiles, preprocess_future); if (created_tiles.size() > 0) { // Read and unfilter coords. @@ -268,6 +309,13 @@ Status SparseGlobalOrderReader::dowork() { stats_->add_counter("ignored_tiles", tmp_read_state_.num_ignored_tiles()); + if (preprocess_future.has_value()) { + // wait for tile merge to complete so we don't have to keep this + // state around for the next iteration, and if this errors for + // some reason we should return that + preprocess_future->merge_.value()->block(); + } + return Status::Ok(); } @@ -389,19 +437,20 @@ bool SparseGlobalOrderReader::add_result_tile( * subarray (e.g. by calling `load_initial_data`) */ template -void SparseGlobalOrderReader< - BitmapType>::preprocess_compute_result_tile_order() { +void SparseGlobalOrderReader::preprocess_compute_result_tile_order( + PreprocessTileMergeFuture& future) { const auto& relevant_fragments = subarray_.relevant_fragments(); const uint64_t num_relevant_fragments = relevant_fragments.size(); - // first apply subarray (in parallel) - std::vector> fragment_result_tiles( - fragment_metadata_.size()); + future.fragment_result_tiles_.resize(fragment_metadata_.size()); + + auto& fragment_result_tiles = future.fragment_result_tiles_; // TODO: ideally this could be async or on demand for each tile // so that we could be closer to a proper LIMIT subarray_.load_relevant_fragment_rtrees(&resources_.compute_tp()); + // first apply subarray (in parallel) if (!subarray_.is_set()) { for (const auto& f : relevant_fragments) { fragment_result_tiles[f].reserve(fragment_metadata_[f]->tile_num()); @@ -460,16 +509,16 @@ void SparseGlobalOrderReader< } /* then do parallel merge */ - std::vector> fragment_result_tile_spans; + auto& fragment_result_tile_spans = future.fragment_result_tile_spans_; fragment_result_tile_spans.reserve(fragment_result_tiles.size()); for (auto& f : fragment_result_tiles) { fragment_result_tile_spans.push_back(std::span(f)); } - std::vector merged_result_tiles( + preprocess_tile_order_.tiles_.resize( num_result_tiles, ResultTileId{.fragment_idx_ = 0, .tile_idx_ = 0}); - algorithm::ParallelMergeOptions merge_options = { + future.merge_options_ = { .parallel_factor = resources_.compute_tp().concurrency_level(), .min_merge_items = 128 // TODO: do some experiments to figure something out @@ -479,13 +528,15 @@ void SparseGlobalOrderReader< *query_memory_tracker_.get()); auto do_global_order_merge = [&]() { - struct ResultTileCmp { + struct ResultTileCmp + : public GlobalCellCmpStaticDispatch { + using Base = GlobalCellCmpStaticDispatch; using PerFragmentMetadata = const std::vector>; ResultTileCmp( const Domain& domain, const PerFragmentMetadata& fragment_metadata) - : cmp_(domain) + : Base(domain) , fragment_metadata_(fragment_metadata) { } @@ -494,26 +545,25 @@ void SparseGlobalOrderReader< .mbr = fragment_metadata_[a.fragment_idx_]->mbr(a.tile_idx_)}; const RangeLowerBound b_mbr = { .mbr = fragment_metadata_[b.fragment_idx_]->mbr(b.tile_idx_)}; - return cmp_(a_mbr, b_mbr); + return (*static_cast(this))(a_mbr, b_mbr); } - GlobalCellCmpStaticDispatch cmp_; const PerFragmentMetadata& fragment_metadata_; }; - ResultTileCmp cmp(array_schema_.domain(), fragment_metadata_); + { + std::shared_ptr cmp = std::make_shared( + array_schema_.domain(), fragment_metadata_); + future.cmp_ = std::static_pointer_cast(cmp); + } - auto merge_stream = algorithm::parallel_merge( + future.merge_ = algorithm::parallel_merge( resources_.compute_tp(), merge_resources, - merge_options, + future.merge_options_, fragment_result_tile_spans, - cmp, - &merged_result_tiles[0]); - - // TODO: we can begin the query as soon as the first merge unit is - // done. this will require extending the lifetime of `cmp`. - merge_stream->block(); + *static_cast(future.cmp_.get()), + &preprocess_tile_order_.tiles_[0]); }; switch (array_schema_.cell_order()) { @@ -554,14 +604,14 @@ void SparseGlobalOrderReader< stdx::unreachable(); } - preprocess_tile_order_.tiles_ = merged_result_tiles; preprocess_tile_order_.cursor_ = 0; } template std::vector SparseGlobalOrderReader::create_result_tiles( - std::vector& result_tiles) { + std::vector& result_tiles, + std::optional& maybe_preprocess_future) { auto timer_se = stats_->start_timer("create_result_tiles"); // Distinguish between leftover result tiles from the previous `submit` @@ -572,7 +622,7 @@ SparseGlobalOrderReader::create_result_tiles( } if (preprocess_tile_order_.enabled_) { - create_result_tiles_using_preprocess(result_tiles); + create_result_tiles_using_preprocess(result_tiles, maybe_preprocess_future); } else { create_result_tiles_all_fragments(result_tiles); } @@ -722,16 +772,37 @@ void SparseGlobalOrderReader::create_result_tiles_all_fragments( template void SparseGlobalOrderReader::create_result_tiles_using_preprocess( - std::vector& result_tiles) { + std::vector& result_tiles, + std::optional& merge_future) { // For easy reference. const auto num_fragments = fragment_metadata_.size(); const auto num_dims = array_schema_.dim_num(); if (preprocess_tile_order_.cursor_ < preprocess_tile_order_.tiles_.size()) { - size_t rt; - for (rt = preprocess_tile_order_.cursor_; - rt < preprocess_tile_order_.tiles_.size(); - rt++) { + size_t rt = preprocess_tile_order_.cursor_; + size_t rt_merge_bound = + (merge_future.has_value() ? rt : preprocess_tile_order_.tiles_.size()); + while (rt < preprocess_tile_order_.tiles_.size()) { + if (rt == rt_merge_bound) { + auto merge_await = merge_future->await(); + if (merge_await.has_value()) { + rt_merge_bound = merge_await.value(); + } else if ((merge_await = + merge_future->merge_.value()->valid_output_bound()) + .has_value()) { + rt_merge_bound = merge_await.value(); + } else { + throw SparseGlobalOrderReaderInternalError( + "Unexpected preprocess tile merge state: expected new merge " + "bound but found none"); + } + if (merge_await.value() <= rt) { + throw SparseGlobalOrderReaderInternalError( + "Unexpected preprocess tile merge state: out of order merge " + "bound"); + } + } + const auto f = preprocess_tile_order_.tiles_[rt].fragment_idx_; const auto t = preprocess_tile_order_.tiles_[rt].tile_idx_; @@ -771,6 +842,7 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( break; } } + rt++; } // update position for next iteration diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index 1cb52c2c348..2e4655224c8 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -51,6 +51,7 @@ using namespace tiledb::common; namespace tiledb::sm { class Array; +struct PreprocessTileMergeFuture; /** Processes sparse global order read queries. */ @@ -245,17 +246,25 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, * Computes the single list of tiles across all fragments * arranged in the order they must be processed for this query. * See `preprocess_tile_order_`. + * + * @param [out] merge_future where to put input for the merge and the merge + * future */ - void preprocess_compute_result_tile_order(); + void preprocess_compute_result_tile_order( + PreprocessTileMergeFuture& merge_future); /** * Create the result tiles. * * @param result_tiles Result tiles per fragment. + * @param maybe_preprocess_future future for polling the global order tile + * stream, if running in preprocess mode + * * @return Newly created tiles. */ std::vector create_result_tiles( - std::vector& result_tiles); + std::vector& result_tiles, + std::optional& maybe_preprocess_future); /** * Create the result tiles naively, without coordinating @@ -275,9 +284,12 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, * tile order. See `preprocess_tile_order_`. * * @param result_tiles [in-out] Result tiles per fragment. + * @param merge_future handle to polling the preprocess merge stream + * (if it has not completed yet) */ void create_result_tiles_using_preprocess( - std::vector& result_tiles); + std::vector& result_tiles, + std::optional& merge_future); /** * Clean tiles that have 0 results from the tile lists. From 4555c408cd6db8825a38aa7168cfef971890ce17 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 19 Dec 2024 14:27:35 -0500 Subject: [PATCH 065/228] Add test for many overlapping fragments being too wide for memory budget --- test/src/unit-sparse-global-order-reader.cc | 112 +++++++++++++++++- test/support/tdb_rapidcheck.h | 33 ++++-- tiledb/sm/misc/comparators.h | 30 +++++ .../readers/sparse_global_order_reader.cc | 15 --- 4 files changed, 160 insertions(+), 30 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 5c1705447f4..1d3e395f81d 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -33,9 +33,13 @@ #include "test/support/rapidcheck/array.h" #include "test/support/src/helpers.h" #include "test/support/src/vfs_helpers.h" +#include "tiledb/api/c_api/array/array_api_internal.h" #include "tiledb/sm/c_api/tiledb.h" #include "tiledb/sm/c_api/tiledb_struct_def.h" #include "tiledb/sm/cpp_api/tiledb" +#include "tiledb/sm/misc/comparators.h" +#include "tiledb/sm/misc/types.h" +#include "tiledb/sm/query/readers/result_tile.h" #include "tiledb/sm/query/readers/sparse_global_order_reader.h" #include "tiledb/sm/stats/duration_instrument.h" @@ -183,6 +187,10 @@ struct CApiArray { operator tiledb_array_t*() const { return array_; } + + tiledb_array_t* operator->() const { + return array_; + } }; struct CSparseGlobalOrderFx { @@ -658,6 +666,96 @@ int32_t CSparseGlobalOrderFx::read_strings( return ret; } +/** + * @return true if the array fragments are "too wide" to merge with the given + * memory budget. "too wide" means that there are overlapping tiles from + * different fragments to fit in memory, so the merge cannot progress without + * producing out-of-order data*. + * + * *there are ways to get around this but they are not implemented. + */ +static bool can_complete_in_memory_budget( + tiledb_ctx_t* ctx, const char* array_uri, const FxRun1D& instance) { + CApiArray array(ctx, array_uri, TILEDB_READ); + + // TODO: verify that the conditions for the error are correct + const auto& fragment_metadata = array->array()->fragment_metadata(); + for (const auto& fragment : fragment_metadata) { + const_cast(fragment.get()) + ->loaded_metadata() + ->load_rtree(array->array()->get_encryption_key()); + } + + auto tiles_size = [fragment_metadata](unsigned f, uint64_t t) { + const size_t data_size = fragment_metadata[f]->tile_size("d", t); + const size_t rt_size = sizeof(sm::GlobalOrderResultTile); + return data_size + rt_size; + }; + + sm::GlobalCellCmp globalcmp(array->array()->array_schema_latest().domain()); + stdx::reverse_comparator reverseglobalcmp(globalcmp); + + using RT = sm::ResultTileId; + + auto cmp_pq_lower_bound = [&](const RT& rtl, const RT& rtr) { + const sm::RangeLowerBound l_mbr = { + .mbr = fragment_metadata[rtl.fragment_idx_]->mbr(rtl.tile_idx_)}; + const sm::RangeLowerBound r_mbr = { + .mbr = fragment_metadata[rtr.fragment_idx_]->mbr(rtr.tile_idx_)}; + return reverseglobalcmp(l_mbr, r_mbr); + }; + auto cmp_pq_upper_bound = [&](const RT& rtl, const RT& rtr) { + const sm::RangeUpperBound l_mbr = { + .mbr = fragment_metadata[rtl.fragment_idx_]->mbr(rtl.tile_idx_)}; + const sm::RangeUpperBound r_mbr = { + .mbr = fragment_metadata[rtr.fragment_idx_]->mbr(rtr.tile_idx_)}; + return reverseglobalcmp(l_mbr, r_mbr); + }; + auto cmp_lower_to_upper = [&](const RT& rtl, const RT& rtr) { + const sm::RangeLowerBound l_mbr = { + .mbr = fragment_metadata[rtl.fragment_idx_]->mbr(rtl.tile_idx_)}; + const sm::RangeUpperBound r_mbr = { + .mbr = fragment_metadata[rtr.fragment_idx_]->mbr(rtr.tile_idx_)}; + return globalcmp(l_mbr, r_mbr); + }; + + // order all tiles on their lower bound + std::priority_queue, decltype(cmp_pq_lower_bound)> + mbr_lower_bound(cmp_pq_lower_bound); + for (unsigned f = 0; f < instance.fragments.size(); f++) { + for (uint64_t t = 0; t < fragment_metadata[f]->tile_num(); t++) { + mbr_lower_bound.push( + sm::ResultTileId{.fragment_idx_ = f, .tile_idx_ = t}); + } + } + + // and track tiles which are active using their upper bound + std::priority_queue, decltype(cmp_pq_upper_bound)> + mbr_upper_bound(cmp_pq_upper_bound); + + // there must be some point where the tiles have overlapping MBRs + // and take more memory + const uint64_t coords_budget = std::stoi(instance.memory.total_budget_) * + std::stod(instance.memory.ratio_coords_); + uint64_t active_tile_size = 0; + while (!mbr_lower_bound.empty() && active_tile_size < coords_budget) { + auto next_rt = mbr_lower_bound.top(); + mbr_lower_bound.pop(); + + active_tile_size += tiles_size(next_rt.fragment_idx_, next_rt.tile_idx_); + mbr_upper_bound.push(next_rt); + + if (!cmp_lower_to_upper(next_rt, mbr_upper_bound.top())) { + auto finish_rt = mbr_upper_bound.top(); + mbr_upper_bound.pop(); + active_tile_size += + tiles_size(finish_rt.fragment_idx_, finish_rt.tile_idx_); + } + } + + return mbr_lower_bound.empty(); +} + /* ********************************* */ /* TESTS */ /* ********************************* */ @@ -1052,7 +1150,7 @@ TEST_CASE_METHOD( */ TEST_CASE_METHOD( CSparseGlobalOrderFx, - "Sparse global order reader: too wide", + "Sparse global order reader: many overlapping fragments", "[sparse-global-order]") { auto doit = [this]( size_t num_fragments, @@ -1060,14 +1158,17 @@ TEST_CASE_METHOD( size_t num_user_cells, const std::vector>& subarray = std::vector>()) { + const uint64_t total_budget = 100000; + const double ratio_coords = 0.2; + FxRun1D instance; instance.array.capacity = num_fragments * 2; instance.array.dimension.extent = num_fragments * 2; instance.array.allow_dups = true; instance.subarray = subarray; - instance.memory.total_budget_ = "100000"; - instance.memory.ratio_coords_ = "0.2"; + instance.memory.total_budget_ = std::to_string(total_budget); + instance.memory.ratio_coords_ = std::to_string(ratio_coords); instance.memory.ratio_array_data_ = "0.6"; for (size_t f = 0; f < num_fragments; f++) { @@ -1089,7 +1190,10 @@ TEST_CASE_METHOD( instance.num_user_cells = num_user_cells; - run_1d(instance); + RCCATCH_THROWS(run_1d(instance)); + + RCCATCH_REQUIRE( + !can_complete_in_memory_budget(ctx_, array_name_.c_str(), instance)); }; SECTION("Example") { diff --git a/test/support/tdb_rapidcheck.h b/test/support/tdb_rapidcheck.h index b5879b9b614..a55978533a7 100644 --- a/test/support/tdb_rapidcheck.h +++ b/test/support/tdb_rapidcheck.h @@ -98,17 +98,28 @@ struct AsserterRapidcheck {}; * the test will continue. For `AsserterRapidcheck` this will throw an * exception. */ -#define RCCATCH_CHECK(...) \ - do { \ - static_assert( \ - std::is_same_type::::value || \ - std::is_same_type:::: \ - value); \ - if (std::is_same_type::::value) { \ - CHECK(__VA_ARGS__); \ - } else { \ - RC_ASSERT(__VA_ARGS__); \ - } \ +#define RCCATCH_CHECK(...) \ + do { \ + static_assert( \ + std::is_same::value || \ + std::is_same::value); \ + if (std::is_same::value) { \ + CHECK(__VA_ARGS__); \ + } else { \ + RC_ASSERT(__VA_ARGS__); \ + } \ + } while (0) + +#define RCCATCH_THROWS(...) \ + do { \ + static_assert( \ + std::is_same::value || \ + std::is_same::value); \ + if (std::is_same::value) { \ + REQUIRE_THROWS(__VA_ARGS__); \ + } else { \ + RC_ASSERT_THROWS(__VA_ARGS__); \ + } \ } while (0) #endif // TILEDB_MISC_TDB_RAPIDCHECK_H diff --git a/tiledb/sm/misc/comparators.h b/tiledb/sm/misc/comparators.h index a4f68083228..33a1b20cb38 100644 --- a/tiledb/sm/misc/comparators.h +++ b/tiledb/sm/misc/comparators.h @@ -690,6 +690,36 @@ class HilbertCmpQB : protected DomainValueCmpBaseQB { } }; +/** + * View into NDRange for using the range start / lower bound in comparisons. + */ +struct RangeLowerBound { + const NDRange& mbr; + + const void* coord(unsigned dim) const { + return mbr[dim].data(); + } + + UntypedDatumView dimension_datum(const Dimension&, unsigned dim) const { + return mbr[dim].start_datum(); + } +}; + +/** + * View into NDRange for using the range end / upper bound in comparisons. + */ +struct RangeUpperBound { + const NDRange& mbr; + + const void* coord(unsigned dim) const { + return mbr[dim].end_datum().content(); + } + + UntypedDatumView dimension_datum(const Dimension&, unsigned dim) const { + return mbr[dim].end_datum(); + } +}; + } // namespace tiledb::sm #endif // TILEDB_COMPARATORS_H diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 5641c1e901f..c043844b97d 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -70,21 +70,6 @@ class SparseGlobalOrderReaderInternalError } }; -/** - * View into NDRange for using the range start / lower bound in comparisons. - */ -struct RangeLowerBound { - const NDRange& mbr; - - const void* coord(unsigned dim) const { - return mbr[dim].data(); - } - - UntypedDatumView dimension_datum(const Dimension&, unsigned dim) const { - return mbr[dim].start_datum(); - } -}; - /** * Encapsulates the input to the preprocess tile merge, and the * merge output future for polling. From 73fb629b6227507d3eaaf9472103bf22e8cf90f0 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 19 Dec 2024 15:38:27 -0500 Subject: [PATCH 066/228] Call can_complete_in_memory_budget in run_1d --- test/src/unit-sparse-global-order-reader.cc | 16 +++++++++++++++- .../query/readers/sparse_global_order_reader.cc | 4 +++- 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 1d3e395f81d..6c04fa754de 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -748,7 +748,7 @@ static bool can_complete_in_memory_budget( if (!cmp_lower_to_upper(next_rt, mbr_upper_bound.top())) { auto finish_rt = mbr_upper_bound.top(); mbr_upper_bound.pop(); - active_tile_size += + active_tile_size -= tiles_size(finish_rt.fragment_idx_, finish_rt.tile_idx_); } } @@ -2163,6 +2163,16 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { RCCATCH_REQUIRE(rc == TILEDB_OK); rc = tiledb_query_submit(ctx_, query); + { + const auto err = error_if_any(rc); + if (err.find("Cannot load enough tiles to emit results from all " + "fragments in global order") != std::string::npos) { + RCCATCH_REQUIRE(!can_complete_in_memory_budget( + ctx_, array_name_.c_str(), instance)); + } else { + RCCATCH_REQUIRE("" == err); + } + } RCCATCH_REQUIRE("" == error_if_any(rc)); tiledb_query_status_t status; @@ -2213,6 +2223,10 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { runlength = 1; } } + + // lastly, check the correctness of our memory budgeting function + RCCATCH_REQUIRE( + can_complete_in_memory_budget(ctx_, array_name_.c_str(), instance)); } namespace rc { diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index c043844b97d..6cee39b10cf 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -264,7 +264,9 @@ Status SparseGlobalOrderReader::dowork() { } if (created_tiles.empty() && result_cell_slabs.empty() && incomplete()) { - throw SparseGlobalOrderReaderException("No progress, TODO"); + throw SparseGlobalOrderReaderException( + "Cannot load enough tiles to emit results from all fragments in " + "global order"); } // No more tiles to process, done. From 1c495b745d083b6a05acf0de18ea9e66e0ca0957 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 19 Dec 2024 19:48:45 -0500 Subject: [PATCH 067/228] Remove commented-out code --- test/support/rapidcheck/array.h | 22 ---------------------- 1 file changed, 22 deletions(-) diff --git a/test/support/rapidcheck/array.h b/test/support/rapidcheck/array.h index 78972ad6503..3db6d668950 100644 --- a/test/support/rapidcheck/array.h +++ b/test/support/rapidcheck/array.h @@ -277,26 +277,6 @@ Gen> make_fragment_2d( auto cells = gen::nonEmpty(gen::container>(cell)); return gen::map(cells, [](std::vector cells) { - /* - std::vector coords_d1; - std::vector coords_d2; - std::tuple...> atts; - - coords_d1.reserve(cells.size()); - coords_d2.reserve(cells.size()); - atts.reserve(cells.size())...; - - for (uint64_t i = 0; i < cells.size(); i++) { - D1 coord_d1; - D2 coord_d2; - Att... att; - std::tie(coord_d1, coord_d2, att...) = cells[i]; - coords_d1.push_back(coord_d1); - coords_d2.push_back(coord_d2); - atts.push_back(att)...; - } - */ - std::vector coords_d1; std::vector coords_d2; std::tuple...> atts; @@ -309,8 +289,6 @@ Gen> make_fragment_2d( }, stdx::transpose(cells)); - // std::tie(coords_d1, coords_d2, atts...) = stdx::transpose(cells); - return Fragment2D{ .d1 = coords_d1, .d2 = coords_d2, .atts = atts}; }); From b555593c49062bd5692a1f8cc07d50609a0235ec Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 19 Dec 2024 19:49:02 -0500 Subject: [PATCH 068/228] show> specialization --- test/support/rapidcheck/array.h | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/test/support/rapidcheck/array.h b/test/support/rapidcheck/array.h index 3db6d668950..004d30bf3fb 100644 --- a/test/support/rapidcheck/array.h +++ b/test/support/rapidcheck/array.h @@ -294,6 +294,11 @@ Gen> make_fragment_2d( }); } +template <> +void show>(const Domain& domain, std::ostream& os) { + os << "[" << domain.lower_bound << ", " << domain.upper_bound << "]"; +} + } // namespace rc #endif From 872f4164f066775cba6fd05f0cb589fd14a68025 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 20 Dec 2024 16:01:04 -0500 Subject: [PATCH 069/228] template Range constructor --- tiledb/type/range/range.h | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/tiledb/type/range/range.h b/tiledb/type/range/range.h index 53d6dea3400..262dafc24ea 100644 --- a/tiledb/type/range/range.h +++ b/tiledb/type/range/range.h @@ -171,6 +171,15 @@ class Range { set_str_range(s1, s2); } + template + Range(const T& start, const T& end, const allocator_type& alloc = {}) + : Range( + static_cast(&start), + static_cast(&end), + sizeof(T), + alloc) { + } + /** * Construct from two values of a fixed size type. * From 82c2871727eb6ce03962f156b0f3755876affa02 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 20 Dec 2024 16:03:08 -0500 Subject: [PATCH 070/228] Rapidcheck for many overlapping fragment test --- test/src/unit-sparse-global-order-reader.cc | 111 ++++++++++++++---- test/support/rapidcheck/array.h | 17 +++ tiledb/sm/misc/comparators.h | 20 ++++ .../readers/sparse_global_order_reader.cc | 37 +++--- .../readers/sparse_global_order_reader.h | 16 ++- 5 files changed, 163 insertions(+), 38 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 6c04fa754de..29393f11555 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -686,10 +686,15 @@ static bool can_complete_in_memory_budget( ->load_rtree(array->array()->get_encryption_key()); } - auto tiles_size = [fragment_metadata](unsigned f, uint64_t t) { + auto tiles_size = [&](unsigned f, uint64_t t) { + using BitmapType = uint8_t; const size_t data_size = fragment_metadata[f]->tile_size("d", t); - const size_t rt_size = sizeof(sm::GlobalOrderResultTile); - return data_size + rt_size; + const size_t rt_size = sizeof(sm::GlobalOrderResultTile); + const size_t subarray_size = + (instance.subarray.empty() ? + 0 : + fragment_metadata[f]->cell_num(t) * sizeof(BitmapType)); + return data_size + rt_size + subarray_size; }; sm::GlobalCellCmp globalcmp(array->array()->array_schema_latest().domain()); @@ -711,12 +716,35 @@ static bool can_complete_in_memory_budget( .mbr = fragment_metadata[rtr.fragment_idx_]->mbr(rtr.tile_idx_)}; return reverseglobalcmp(l_mbr, r_mbr); }; - auto cmp_lower_to_upper = [&](const RT& rtl, const RT& rtr) { - const sm::RangeLowerBound l_mbr = { + + /** + * @return true if `rtl.upper < rtr.lower`, i.e. we can process + * the entirety of `rtl` before any of `rtr` + */ + auto cmp_upper_to_lower = [&](const RT& rtl, const RT& rtr) { + const sm::RangeUpperBound l_mbr = { .mbr = fragment_metadata[rtl.fragment_idx_]->mbr(rtl.tile_idx_)}; - const sm::RangeUpperBound r_mbr = { + const sm::RangeLowerBound r_mbr = { .mbr = fragment_metadata[rtr.fragment_idx_]->mbr(rtr.tile_idx_)}; - return globalcmp(l_mbr, r_mbr); + + int cmp; + if (instance.subarray.empty()) { + cmp = globalcmp.compare(l_mbr, r_mbr); + } else { + assert(instance.subarray.size() == 1); // need to tweak this logic if not + + const auto& subarray = instance.subarray[0]; + if (subarray.upper_bound < *static_cast(l_mbr.coord(0))) { + // in this case, the bitmap will filter out the other coords in the + // tile and it will be discarded + std::vector subarrayrange = {subarray.range()}; + const sm::RangeUpperBound sub_mbr = {.mbr = subarrayrange}; + cmp = globalcmp.compare(sub_mbr, r_mbr); + } else { + cmp = globalcmp.compare(l_mbr, r_mbr); + } + } + return cmp <= 0; }; // order all tiles on their lower bound @@ -724,8 +752,22 @@ static bool can_complete_in_memory_budget( mbr_lower_bound(cmp_pq_lower_bound); for (unsigned f = 0; f < instance.fragments.size(); f++) { for (uint64_t t = 0; t < fragment_metadata[f]->tile_num(); t++) { - mbr_lower_bound.push( - sm::ResultTileId{.fragment_idx_ = f, .tile_idx_ = t}); + if (instance.subarray.empty()) { + mbr_lower_bound.push( + sm::ResultTileId{.fragment_idx_ = f, .tile_idx_ = t}); + } else { + auto accept = [&](const auto& range) { + const auto& untyped_mbr = fragment_metadata[f]->mbr(t)[0]; + const tdbrc::Domain typed_mbr( + untyped_mbr.start_as(), untyped_mbr.end_as()); + return range.intersects(typed_mbr); + }; + if (std::any_of( + instance.subarray.begin(), instance.subarray.end(), accept)) { + mbr_lower_bound.push( + sm::ResultTileId{.fragment_idx_ = f, .tile_idx_ = t}); + } + } } } @@ -738,14 +780,33 @@ static bool can_complete_in_memory_budget( const uint64_t coords_budget = std::stoi(instance.memory.total_budget_) * std::stod(instance.memory.ratio_coords_); uint64_t active_tile_size = 0; - while (!mbr_lower_bound.empty() && active_tile_size < coords_budget) { - auto next_rt = mbr_lower_bound.top(); - mbr_lower_bound.pop(); + uint64_t next_tile_size = 0; + while (active_tile_size + next_tile_size < coords_budget && + !mbr_lower_bound.empty()) { + RT next_rt; + + // add new result tiles + while (!mbr_lower_bound.empty()) { + next_rt = mbr_lower_bound.top(); + + next_tile_size = tiles_size(next_rt.fragment_idx_, next_rt.tile_idx_); + if (active_tile_size + next_tile_size <= coords_budget) { + mbr_lower_bound.pop(); + active_tile_size += next_tile_size; + mbr_upper_bound.push(next_rt); + } else { + break; + } + } - active_tile_size += tiles_size(next_rt.fragment_idx_, next_rt.tile_idx_); - mbr_upper_bound.push(next_rt); + if (mbr_lower_bound.empty()) { + break; + } - if (!cmp_lower_to_upper(next_rt, mbr_upper_bound.top())) { + // emit from created result tiles, removing any which are exhausted + next_rt = mbr_lower_bound.top(); + while (!mbr_upper_bound.empty() && + cmp_upper_to_lower(mbr_upper_bound.top(), next_rt)) { auto finish_rt = mbr_upper_bound.top(); mbr_upper_bound.pop(); active_tile_size -= @@ -1190,15 +1251,24 @@ TEST_CASE_METHOD( instance.num_user_cells = num_user_cells; - RCCATCH_THROWS(run_1d(instance)); - - RCCATCH_REQUIRE( - !can_complete_in_memory_budget(ctx_, array_name_.c_str(), instance)); + run_1d(instance); }; SECTION("Example") { doit.operator()(16, 100, 64); } + + SECTION("Rapidcheck") { + rc::prop("rapidcheck many overlapping fragments", [doit]() { + const size_t num_fragments = *rc::gen::inRange(10, 24); + const size_t fragment_size = *rc::gen::inRange(2, 200 - 64); + // const size_t num_user_cells = *rc::gen::inRange(1, 1024 * 1024); + const size_t num_user_cells = 1024; + const auto subarray = *rc::make_subarray_1d(tdbrc::Domain(1, 200)); + doit.operator()( + num_fragments, fragment_size, num_user_cells, subarray); + }); + } } TEST_CASE_METHOD( @@ -2169,11 +2239,12 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { "fragments in global order") != std::string::npos) { RCCATCH_REQUIRE(!can_complete_in_memory_budget( ctx_, array_name_.c_str(), instance)); + tiledb_query_free(&query); + return; } else { RCCATCH_REQUIRE("" == err); } } - RCCATCH_REQUIRE("" == error_if_any(rc)); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); diff --git a/test/support/rapidcheck/array.h b/test/support/rapidcheck/array.h index 004d30bf3fb..6afb42eca63 100644 --- a/test/support/rapidcheck/array.h +++ b/test/support/rapidcheck/array.h @@ -35,6 +35,8 @@ #ifndef TILEDB_RAPIDCHECK_ARRAY_H #define TILEDB_RAPIDCHECK_ARRAY_H +#include "tiledb/type/range/range.h" + #include #include @@ -80,6 +82,21 @@ struct Domain { bool contains(D point) const { return lower_bound <= point && point <= upper_bound; } + + bool intersects(const Domain& other) const { + return (other.lower_bound <= lower_bound && + lower_bound <= other.upper_bound) || + (other.lower_bound <= upper_bound && + upper_bound <= other.upper_bound) || + (lower_bound <= other.lower_bound && + other.lower_bound <= upper_bound) || + (lower_bound <= other.upper_bound && + other.upper_bound <= upper_bound); + } + + tiledb::type::Range range() const { + return tiledb::type::Range(lower_bound, upper_bound); + } }; /** diff --git a/tiledb/sm/misc/comparators.h b/tiledb/sm/misc/comparators.h index 33a1b20cb38..dd793804eeb 100644 --- a/tiledb/sm/misc/comparators.h +++ b/tiledb/sm/misc/comparators.h @@ -66,6 +66,26 @@ struct reverse_comparator { } }; +/** + * Generic comparator adapter which transforms a `int compare(a, b)` function + * into a `bool operator` which returns true if `a <= b` + * (whereas a typical comparator's `bool operator` returns true if `a < b`). + */ +template +struct or_equal { + Comparator inner_; + + template + or_equal(Args&&... args) + : inner_(std::forward(args)...) { + } + + template + bool operator()(const L& a, const R& b) const { + return inner_.compare(a, b) <= 0; + } +}; + } // namespace stdx namespace tiledb::sm { diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 6cee39b10cf..264b5c7f853 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -1114,7 +1114,7 @@ bool SparseGlobalOrderReader::add_all_dups_to_queue( template template -bool SparseGlobalOrderReader::add_next_cell_to_queue( +AddNextCellResult SparseGlobalOrderReader::add_next_cell_to_queue( GlobalOrderResultCoords& rc, std::vector& result_tiles_it, const std::vector& result_tiles, @@ -1127,7 +1127,7 @@ bool SparseGlobalOrderReader::add_next_cell_to_queue( // This would be because a cell after this one in the fragment was added to // the queue as it had the same coordinates as this one. if (!rc.has_next_) { - return false; + return AddNextCellResult::Done; } // Try the next cell in the same tile. @@ -1162,11 +1162,11 @@ bool SparseGlobalOrderReader::add_next_cell_to_queue( // This fragment has more tiles potentially. if (!tmp_read_state_.all_tiles_loaded(frag_idx)) { // Return we need more tiles. - return true; + return AddNextCellResult::NeedMoreTiles; } // All tiles processed, done. - return false; + return AddNextCellResult::Done; } } @@ -1176,7 +1176,7 @@ bool SparseGlobalOrderReader::add_next_cell_to_queue( // with timestamps if not all tiles are loaded. if (!dups && last_in_memory_cell_of_consolidated_fragment( frag_idx, rc, result_tiles)) { - return true; + return AddNextCellResult::NeedMoreTiles; } // If the cell value exceeds the lower bound of the un-populated result @@ -1207,7 +1207,7 @@ bool SparseGlobalOrderReader::add_next_cell_to_queue( // 2) scenario where this does make progress because we // finish a tile and thus gain budget to load the next one - return true; + return AddNextCellResult::MergeBound; } } } @@ -1220,14 +1220,14 @@ bool SparseGlobalOrderReader::add_next_cell_to_queue( fragment_metadata_[frag_idx]->has_timestamps()) { if (add_all_dups_to_queue( rc, result_tiles_it, result_tiles, tile_queue, to_delete)) { - return true; + return AddNextCellResult::NeedMoreTiles; } } tile_queue.emplace(std::move(rc)); } // We don't need more tiles as a tile was found. - return false; + return AddNextCellResult::FoundCell; } template @@ -1317,7 +1317,7 @@ SparseGlobalOrderReader::merge_result_cell_slabs( TileMinHeap tile_queue(cmp, std::move(container)); // If any fragments needs to load more tiles. - bool need_more_tiles = false; + AddNextCellResult add_next_cell_result; // Tile iterators, per fragments. std::vector rt_it(result_tiles.size()); @@ -1336,11 +1336,13 @@ SparseGlobalOrderReader::merge_result_cell_slabs( read_state_.frag_idx()[f].cell_idx_ : 0; GlobalOrderResultCoords rc(&*(rt_it[f]), cell_idx); - bool res = add_next_cell_to_queue( + auto res = add_next_cell_to_queue( rc, rt_it, result_tiles, tile_queue, to_delete); { std::unique_lock ul(tile_queue_mutex_); - need_more_tiles |= res; + if (res == AddNextCellResult::NeedMoreTiles) { + add_next_cell_result = res; + } } } @@ -1351,7 +1353,9 @@ SparseGlobalOrderReader::merge_result_cell_slabs( // Process all elements. bool user_buffers_full = false; - while (!tile_queue.empty() && !need_more_tiles && num_cells > 0) { + while (!tile_queue.empty() && + add_next_cell_result != AddNextCellResult::NeedMoreTiles && + num_cells > 0) { auto to_process = tile_queue.top(); auto tile = to_process.tile_; tile_queue.pop(); @@ -1411,13 +1415,13 @@ SparseGlobalOrderReader::merge_result_cell_slabs( tile_queue.pop(); // Put the next cell from the processed tile in the queue. - need_more_tiles = add_next_cell_to_queue( + add_next_cell_result = add_next_cell_to_queue( to_remove, rt_it, result_tiles, tile_queue, to_delete); } else { update_frag_idx(tile, to_process.pos_ + 1); // Put the next cell from the processed tile in the queue. - need_more_tiles = add_next_cell_to_queue( + add_next_cell_result = add_next_cell_to_queue( to_process, rt_it, result_tiles, tile_queue, to_delete); to_process = tile_queue.top(); @@ -1458,7 +1462,8 @@ SparseGlobalOrderReader::merge_result_cell_slabs( fragment_metadata_[next_global_order_tile.fragment_idx_]->mbr( next_global_order_tile.tile_idx_); RangeLowerBound global_order_lower_bound = {.mbr = emit_bound}; - stdx::reverse_comparator cmp(array_schema_.domain()); + stdx::reverse_comparator> cmp( + stdx::or_equal(array_schema_.domain())); if (tile_queue.empty()) { length = to_process.max_slab_length(global_order_lower_bound, cmp); } else if (cmp(tile_queue.top(), global_order_lower_bound)) { @@ -1523,7 +1528,7 @@ SparseGlobalOrderReader::merge_result_cell_slabs( } // Put the next cell in the queue. - need_more_tiles = add_next_cell_to_queue( + add_next_cell_result = add_next_cell_to_queue( to_process, rt_it, result_tiles, tile_queue, to_delete); } diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index 2e4655224c8..4623b2ad1a2 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -53,6 +53,18 @@ namespace tiledb::sm { class Array; struct PreprocessTileMergeFuture; +enum class AddNextCellResult { + // finished the current tile + Done, + // successfully added a cell to the queue + FoundCell, + // more tiles from the same fragment are needed to continue + NeedMoreTiles, + // this tile cannot continue because it would be out of order with + // un-created result tiles + MergeBound +}; + /** Processes sparse global order read queries. */ template @@ -372,10 +384,10 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, * @param tile_queue Queue of one result coords, per fragment, sorted. * @param to_delete List of tiles to delete. * - * @return If more tiles are needed. + * @return result of trying to add a cell */ template - bool add_next_cell_to_queue( + AddNextCellResult add_next_cell_to_queue( GlobalOrderResultCoords& rc, std::vector& result_tiles_it, const std::vector& result_tiles, From 3a40589c3820ca6c369bd5a5a48194c8a45d0c77 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 20 Dec 2024 16:13:33 -0500 Subject: [PATCH 071/228] Add subarrays to existing tests --- test/src/unit-sparse-global-order-reader.cc | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 29393f11555..487555d7081 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -1125,7 +1125,9 @@ TEST_CASE_METHOD( "[sparse-global-order]") { // NB: the tile extent is 2 auto doit = [this]( - size_t fragment_size, size_t num_user_cells) { + size_t fragment_size, + size_t num_user_cells, + const std::vector>& subarray = {}) { struct FxFragment1D fragment0; struct FxFragment1D fragment1; @@ -1154,6 +1156,7 @@ TEST_CASE_METHOD( instance.fragments.push_back(fragment0); instance.fragments.push_back(fragment1); instance.num_user_cells = num_user_cells; + instance.subarray = subarray; instance.memory.total_budget_ = "20000"; instance.memory.ratio_array_data_ = "0.5"; instance.array.allow_dups = true; @@ -1169,8 +1172,9 @@ TEST_CASE_METHOD( rc::prop("rapidcheck fragment interleave", [doit]() { const size_t fragment_size = *rc::gen::inRange(2, 196); const size_t num_user_cells = *rc::gen::inRange(1, 1024); + const auto subarray = *rc::make_subarray_1d(tdbrc::Domain(1, 200)); doit.operator()( - fragment_size, num_user_cells); + fragment_size, num_user_cells, subarray); }); } @@ -2335,8 +2339,9 @@ struct Arbitrary { .coords = fragment.dim, .atts = std::get<0>(fragment.atts)}; }); - return gen::pair( + return gen::tuple( gen::just(dimension), + make_subarray_1d(dimension.domain), gen::nonEmpty( gen::container>(fragment))); }); @@ -2344,11 +2349,15 @@ struct Arbitrary { auto num_user_cells = gen::inRange(1, 8 * 1024 * 1024); return gen::apply( - [](std::pair, std::vector> - fragments, + [](std::tuple< + tdbrc::Dimension, + std::vector>, + std::vector> fragments, int num_user_cells) { FxRun1D instance; - std::tie(instance.array.dimension, instance.fragments) = fragments; + std::tie( + instance.array.dimension, instance.subarray, instance.fragments) = + fragments; instance.num_user_cells = num_user_cells; instance.array.allow_dups = true; From 3e93a5160d01be1646879076ac1b2b9a9fbc889f Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 23 Dec 2024 16:25:16 -0500 Subject: [PATCH 072/228] datatype_traits --- tiledb/type/apply_with_type.h | 95 ++++++-------- tiledb/type/datatype_traits.h | 235 ++++++++++++++++++++++++++++++++++ 2 files changed, 273 insertions(+), 57 deletions(-) create mode 100644 tiledb/type/datatype_traits.h diff --git a/tiledb/type/apply_with_type.h b/tiledb/type/apply_with_type.h index 3ac89f9abe5..310ff3dc3d3 100644 --- a/tiledb/type/apply_with_type.h +++ b/tiledb/type/apply_with_type.h @@ -34,6 +34,7 @@ #define TILEDB_APPLY_WITH_TYPE_H #include "tiledb/sm/enums/datatype.h" +#include "tiledb/type/datatype_traits.h" using tiledb::sm::Datatype; @@ -56,64 +57,44 @@ concept TileDBNumeric = TileDBIntegral || std::floating_point; */ template inline auto apply_with_type(Fn&& f, Datatype type, Args&&... args) { +#define CASE(type) \ + case (type): \ + return f(datatype_traits<(type)>::value_type{}, std::forward(args)...) + switch (type) { - case Datatype::INT32: { - return f(int32_t{}, std::forward(args)...); - } - case Datatype::INT64: { - return f(int64_t{}, std::forward(args)...); - } - case Datatype::INT8: { - return f(int8_t{}, std::forward(args)...); - } - case Datatype::UINT8: { - return f(uint8_t{}, std::forward(args)...); - } - case Datatype::INT16: { - return f(int16_t{}, std::forward(args)...); - } - case Datatype::UINT16: { - return f(uint16_t{}, std::forward(args)...); - } - case Datatype::UINT32: { - return f(uint32_t{}, std::forward(args)...); - } - case Datatype::UINT64: { - return f(uint64_t{}, std::forward(args)...); - } - case Datatype::FLOAT32: { - return f(float{}, std::forward(args)...); - } - case Datatype::FLOAT64: { - return f(double{}, std::forward(args)...); - } - case Datatype::DATETIME_YEAR: - case Datatype::DATETIME_MONTH: - case Datatype::DATETIME_WEEK: - case Datatype::DATETIME_DAY: - case Datatype::DATETIME_HR: - case Datatype::DATETIME_MIN: - case Datatype::DATETIME_SEC: - case Datatype::DATETIME_MS: - case Datatype::DATETIME_US: - case Datatype::DATETIME_NS: - case Datatype::DATETIME_PS: - case Datatype::DATETIME_FS: - case Datatype::DATETIME_AS: - case Datatype::TIME_HR: - case Datatype::TIME_MIN: - case Datatype::TIME_SEC: - case Datatype::TIME_MS: - case Datatype::TIME_US: - case Datatype::TIME_NS: - case Datatype::TIME_PS: - case Datatype::TIME_FS: - case Datatype::TIME_AS: { - return f(int64_t{}, std::forward(args)...); - } - case Datatype::STRING_ASCII: { - return f(char{}, std::forward(args)...); - } + CASE(Datatype::INT32); + CASE(Datatype::INT64); + CASE(Datatype::INT8); + CASE(Datatype::UINT8); + CASE(Datatype::INT16); + CASE(Datatype::UINT16); + CASE(Datatype::UINT32); + CASE(Datatype::UINT64); + CASE(Datatype::FLOAT32); + CASE(Datatype::FLOAT64); + CASE(Datatype::DATETIME_YEAR); + CASE(Datatype::DATETIME_MONTH); + CASE(Datatype::DATETIME_WEEK); + CASE(Datatype::DATETIME_DAY); + CASE(Datatype::DATETIME_HR); + CASE(Datatype::DATETIME_MIN); + CASE(Datatype::DATETIME_SEC); + CASE(Datatype::DATETIME_MS); + CASE(Datatype::DATETIME_US); + CASE(Datatype::DATETIME_NS); + CASE(Datatype::DATETIME_PS); + CASE(Datatype::DATETIME_FS); + CASE(Datatype::DATETIME_AS); + CASE(Datatype::TIME_HR); + CASE(Datatype::TIME_MIN); + CASE(Datatype::TIME_SEC); + CASE(Datatype::TIME_MS); + CASE(Datatype::TIME_US); + CASE(Datatype::TIME_NS); + CASE(Datatype::TIME_PS); + CASE(Datatype::TIME_FS); + CASE(Datatype::TIME_AS); + CASE(Datatype::STRING_ASCII); default: { throw std::logic_error( "Datatype::" + datatype_str(type) + " is not a supported Datatype"); diff --git a/tiledb/type/datatype_traits.h b/tiledb/type/datatype_traits.h new file mode 100644 index 00000000000..e38c5883a25 --- /dev/null +++ b/tiledb/type/datatype_traits.h @@ -0,0 +1,235 @@ +/** + * @file tiledb/type/datatype_traits.h + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2023-2024 TileDB, 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. + * + * @section DESCRIPTION + * + * This file declares `datatype_traits` which provides definitions for + * generic programming over Datatypes + */ + +#ifndef TILEDB_DATATYPE_TRAITS_H +#define TILEDB_DATATYPE_TRAITS_H + +#include "tiledb/sm/enums/datatype.h" + +using tiledb::sm::Datatype; + +namespace tiledb::type { + +/** + * `datatype_traits` + * + * This will be specialized for each `Datatype` + */ +template +struct datatype_traits {}; + +template <> +struct datatype_traits { + using value_type = int32_t; +}; + +template <> +struct datatype_traits { + using value_type = int64_t; +}; + +template <> +struct datatype_traits { + using value_type = int8_t; +}; + +template <> +struct datatype_traits { + using value_type = uint8_t; +}; + +template <> +struct datatype_traits { + using value_type = int16_t; +}; + +template <> +struct datatype_traits { + using value_type = uint16_t; +}; + +template <> +struct datatype_traits { + using value_type = uint32_t; +}; + +template <> +struct datatype_traits { + using value_type = uint64_t; +}; + +template <> +struct datatype_traits { + using value_type = float; +}; + +template <> +struct datatype_traits { + using value_type = double; +}; + +struct datatype_datetime_traits { + using value_type = int64_t; +}; + +template <> +struct datatype_traits + : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits + : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits + : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits + : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits + : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits + : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits + : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits + : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits + : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits + : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits + : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits + : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits + : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits : private datatype_datetime_traits { + using datatype_datetime_traits::value_type; +}; + +template <> +struct datatype_traits { + using value_type = char; +}; + +} // namespace tiledb::type + +#endif From 5b9ed6de782aa12ab3e1f9eaa55098f520ba0919 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 23 Dec 2024 16:33:50 -0500 Subject: [PATCH 073/228] Genericize write_fragment and create_array --- test/src/unit-sparse-global-order-reader.cc | 256 ++++++++++++++++++-- test/support/rapidcheck/array.h | 70 ++++-- 2 files changed, 284 insertions(+), 42 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 487555d7081..2762d83a50b 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -37,6 +37,7 @@ #include "tiledb/sm/c_api/tiledb.h" #include "tiledb/sm/c_api/tiledb_struct_def.h" #include "tiledb/sm/cpp_api/tiledb" +#include "tiledb/sm/enums/datatype.h" #include "tiledb/sm/misc/comparators.h" #include "tiledb/sm/misc/types.h" #include "tiledb/sm/query/readers/result_tile.h" @@ -58,6 +59,11 @@ using namespace tiledb; using namespace tiledb::test; +using tiledb::sm::Datatype; +using tiledb::test::tdbrc::AttributeType; +using tiledb::test::tdbrc::DimensionType; +using tiledb::test::tdbrc::FragmentType; + namespace rc { Gen>> make_subarray_1d( const tdbrc::Domain& domain); @@ -74,6 +80,14 @@ Gen>> make_subarray_1d( struct FxFragment1D { std::vector coords; std::vector atts; + + std::tuple&> dimensions() const { + return std::tuple&>(coords); + } + + std::tuple&> attributes() const { + return std::tuple&>(atts); + } }; struct MemoryBudget { @@ -97,7 +111,7 @@ struct DefaultArray1DConfig { uint64_t capacity; bool allow_dups; - tdbrc::Dimension dimension; + tdbrc::Dimension dimension; DefaultArray1DConfig() : capacity(2) @@ -140,6 +154,15 @@ struct FxRun1D { return false; } } + + std::tuple&> dimensions() const { + return std::tuple&>( + array.dimension); + } + + std::tuple attributes() const { + return std::make_tuple(Datatype::INT32); + } }; /** @@ -193,6 +216,13 @@ struct CApiArray { } }; +template +concept InstanceType = requires(const T& instance) { + instance.fragments; + instance.dimensions(); + instance.attributes(); +}; + struct CSparseGlobalOrderFx { tiledb_ctx_t* ctx_ = nullptr; tiledb_vfs_t* vfs_ = nullptr; @@ -213,6 +243,9 @@ struct CSparseGlobalOrderFx { void write_1d_fragment( int* coords, uint64_t* coords_size, int* data, uint64_t* data_size); + template + void write_fragment(const Fragment& fragment); + void write_1d_fragment_strings( int* coords, uint64_t* coords_size, @@ -245,6 +278,9 @@ struct CSparseGlobalOrderFx { void reset_config(); void update_config(); + template + void create_array(const Instance& instance); + /** * Runs an input against a fresh 1D array. * Inserts fragments one at a time, then reads them back in global order @@ -383,7 +419,7 @@ void CSparseGlobalOrderFx::create_default_array_1d( RCCATCH_REQUIRE("" == error_if_any(rc)); } - create_array( + tiledb::test::create_array( ctx_, array_name_, TILEDB_SPARSE, @@ -404,7 +440,7 @@ void CSparseGlobalOrderFx::create_default_array_1d( void CSparseGlobalOrderFx::create_default_array_1d_strings(bool allow_dups) { int domain[] = {1, 200}; int tile_extent = 2; - create_array( + tiledb::test::create_array( ctx_, array_name_, TILEDB_SPARSE, @@ -447,6 +483,115 @@ void CSparseGlobalOrderFx::write_1d_fragment( tiledb_query_free(&query); } +template +void CSparseGlobalOrderFx::write_fragment(const Fragment& fragment) { + // Open array for writing. + CApiArray array(ctx_, array_name_.c_str(), TILEDB_WRITE); + + const std::tuple&> dimensions = fragment.dimensions(); + const std::tuple&> attributes = fragment.attributes(); + + // make field size locations + std::optional num_cells; + auto make_field_size = [&num_cells](const std::vector& field) { + const uint64_t field_size = field.size() * sizeof(T); + if (num_cells.has_value()) { + // precondition: each field must have the same number of cells + RCCATCH_REQUIRE(field.size() == num_cells.value()); + } else { + num_cells.emplace(field.size()); + } + return field_size; + }; + + std::tuple dimension_sizes = std::apply( + [make_field_size](const std::vector&... dimension) { + return std::make_tuple(make_field_size(dimension)...); + }, + dimensions); + + std::tuple attribute_sizes = std::apply( + [make_field_size](const std::vector&... attribute) { + return std::make_tuple(make_field_size(attribute)...); + }, + attributes); + + // Create the query. + tiledb_query_t* query; + auto rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); + RCCATCH_REQUIRE(rc == TILEDB_OK); + rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); + RCCATCH_REQUIRE(rc == TILEDB_OK); + + auto set_data_buffer = [this, query]( + const std::string& name, + const std::vector& field, + uint64_t& field_size) { + auto rc = tiledb_query_set_data_buffer( + ctx_, query, name.c_str(), const_cast(field.data()), &field_size); + RCCATCH_REQUIRE("" == error_if_any(rc)); + }; + + // add dimensions to query + uint64_t d = 1; + std::apply( + [&](const std::vector&... dimension) { + std::apply( + [&](Us&... dimension_size) { + (set_data_buffer( + "d" + std::to_string(d++), dimension, dimension_size), + ...); + }, + dimension_sizes); + }, + dimensions); + + // add attributes to query + uint64_t a = 1; + std::apply( + [&](const std::vector&... attribute) { + std::apply( + [&](Us&... attribute_size) { + (set_data_buffer( + "a" + std::to_string(a++), attribute, attribute_size), + ...); + }, + attribute_sizes); + }, + attributes); + + // Submit query. + rc = tiledb_query_submit(ctx_, query); + RCCATCH_REQUIRE("" == error_if_any(rc)); + + // check that sizes match what we expect + auto require_full_write = + [](const std::vector& field, uint64_t write_size) { + RCCATCH_REQUIRE(write_size == field.size() * sizeof(T)); + }; + std::apply( + [&](const std::vector&... dimension) { + std::apply( + [&](const Us&... dimension_size) { + (require_full_write(dimension, dimension_size), ...); + }, + dimension_sizes); + }, + dimensions); + std::apply( + [&](const std::vector&... attribute) { + std::apply( + [&](const Us&... attribute_size) { + (require_full_write(attribute, attribute_size), ...); + }, + attribute_sizes); + }, + attributes); + + // Clean up. + tiledb_query_free(&query); +} + void CSparseGlobalOrderFx::write_1d_fragment_strings( int* coords, uint64_t* coords_size, @@ -688,7 +833,7 @@ static bool can_complete_in_memory_budget( auto tiles_size = [&](unsigned f, uint64_t t) { using BitmapType = uint8_t; - const size_t data_size = fragment_metadata[f]->tile_size("d", t); + const size_t data_size = fragment_metadata[f]->tile_size("d1", t); const size_t rt_size = sizeof(sm::GlobalOrderResultTile); const size_t subarray_size = (instance.subarray.empty() ? @@ -2122,6 +2267,69 @@ TEST_CASE_METHOD( tiledb_query_free(&query); } +template +void CSparseGlobalOrderFx::create_array(const Instance& instance) { + tiledb_object_t type; + auto rc = tiledb_object_type(ctx_, array_name_.c_str(), &type); + RCCATCH_REQUIRE(rc == TILEDB_OK); + if (type == TILEDB_ARRAY) { + rc = tiledb_array_delete(ctx_, array_name_.c_str()); + RCCATCH_REQUIRE("" == error_if_any(rc)); + } + + const auto dimensions = instance.dimensions(); + const auto attributes = instance.attributes(); + + std::vector dimension_names; + std::vector dimension_types; + std::vector dimension_ranges; + std::vector dimension_extents; + auto add_dimension = [&](const tdbrc::Dimension& dimension) { + using CoordType = tdbrc::Dimension::value_type; + dimension_names.push_back("d" + std::to_string(dimension_names.size() + 1)); + dimension_types.push_back(static_cast(D)); + dimension_ranges.push_back( + const_cast(&dimension.domain.lower_bound)); + dimension_extents.push_back(const_cast(&dimension.extent)); + }; + std::apply( + [&](const tdbrc::Dimension&... dimension) { + (add_dimension(dimension), ...); + }, + dimensions); + + std::vector attribute_names; + std::vector attribute_types; + std::vector attribute_cell_val_nums; + std::vector> attribute_compressors; + auto add_attribute = [&](Datatype attribute) { + attribute_names.push_back("a" + std::to_string(attribute_names.size() + 1)); + attribute_types.push_back(static_cast(attribute)); + attribute_cell_val_nums.push_back(1); + attribute_compressors.push_back(std::make_pair(TILEDB_FILTER_NONE, -1)); + }; + std::apply( + [&](As... attribute) { (add_attribute(attribute), ...); }, + attributes); + + tiledb::test::create_array( + ctx_, + array_name_, + TILEDB_SPARSE, + dimension_names, + dimension_types, + dimension_ranges, + dimension_extents, + attribute_names, + attribute_types, + attribute_cell_val_nums, + attribute_compressors, + TILEDB_ROW_MAJOR, + TILEDB_ROW_MAJOR, + instance.array.capacity, + instance.array.allow_dups); +} + template void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { RCCATCH_REQUIRE(instance.num_user_cells > 0); @@ -2132,20 +2340,12 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { update_config(); // the tile extent is 2 - create_default_array_1d(instance.array); + // create_default_array_1d(instance.array); + create_array(instance); // write all fragments for (auto& fragment : instance.fragments) { - uint64_t coords_size = sizeof(int) * fragment.coords.size(); - uint64_t atts_size = sizeof(int) * fragment.atts.size(); - - // precondition: fragment must have the same number of cells for each field - RCCATCH_REQUIRE(coords_size == atts_size); - - write_1d_fragment( - fragment.coords.data(), &coords_size, fragment.atts.data(), &atts_size); - RCCATCH_REQUIRE(coords_size == sizeof(int) * fragment.coords.size()); - RCCATCH_REQUIRE(atts_size == sizeof(int) * fragment.atts.size()); + write_fragment(fragment); } std::vector expectcoords; @@ -2230,11 +2430,11 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { outcoords_size = outatts_size = instance.num_user_cells * sizeof(int); rc = tiledb_query_set_data_buffer( - ctx_, query, "a", &outatts[outcursor], &outatts_size); - RCCATCH_REQUIRE(rc == TILEDB_OK); + ctx_, query, "a1", &outatts[outcursor], &outatts_size); + RCCATCH_REQUIRE("" == error_if_any(rc)); rc = tiledb_query_set_data_buffer( - ctx_, query, "d", &outcoords[outcursor], &outcoords_size); - RCCATCH_REQUIRE(rc == TILEDB_OK); + ctx_, query, "d1", &outcoords[outcursor], &outcoords_size); + RCCATCH_REQUIRE("" == error_if_any(rc)); rc = tiledb_query_submit(ctx_, query); { @@ -2328,15 +2528,19 @@ Gen>> make_subarray_1d( template <> struct Arbitrary { static Gen arbitrary() { - auto dimension = gen::arbitrary>(); + constexpr Datatype DimensionType = Datatype::INT32; + using CoordType = tiledb::type::datatype_traits::value_type; + + auto dimension = gen::arbitrary>(); auto fragments = - gen::mapcat(dimension, [](tdbrc::Dimension dimension) { + gen::mapcat(dimension, [](tdbrc::Dimension dimension) { auto fragment = gen::map( - rc::make_fragment_1d(dimension.domain), - [](tdbrc::Fragment1D fragment) { + rc::make_fragment_1d(dimension.domain), + [](tdbrc::Fragment1D fragment) { return FxFragment1D{ - .coords = fragment.dim, .atts = std::get<0>(fragment.atts)}; + .coords = fragment.dim_, + .atts = std::get<0>(fragment.atts_)}; }); return gen::tuple( @@ -2350,8 +2554,8 @@ struct Arbitrary { return gen::apply( [](std::tuple< - tdbrc::Dimension, - std::vector>, + tdbrc::Dimension, + std::vector>, std::vector> fragments, int num_user_cells) { FxRun1D instance; diff --git a/test/support/rapidcheck/array.h b/test/support/rapidcheck/array.h index 6afb42eca63..5f4ffb45e5a 100644 --- a/test/support/rapidcheck/array.h +++ b/test/support/rapidcheck/array.h @@ -35,6 +35,7 @@ #ifndef TILEDB_RAPIDCHECK_ARRAY_H #define TILEDB_RAPIDCHECK_ARRAY_H +#include "tiledb/type/datatype_traits.h" #include "tiledb/type/range/range.h" #include @@ -63,6 +64,14 @@ template concept AttributeType = requires(const T& coord) { typename ::rc::Arbitrary; }; +template +concept FragmentType = requires(const T& fragment) { + // not sure how to specify "returns any tuple whose elements decay to + // std::vector" + fragment.dimensions(); + fragment.attributes(); +}; + /** * A generic, statically-typed range which is inclusive on both ends. */ @@ -102,10 +111,12 @@ struct Domain { /** * A description of a dimension as it pertains to its datatype. */ -template +template struct Dimension { - Domain domain; - D extent; + using value_type = tiledb::type::datatype_traits::value_type; + + Domain domain; + value_type extent; }; /** @@ -113,8 +124,20 @@ struct Dimension { */ template struct Fragment1D { - std::vector dim; - std::tuple...> atts; + std::vector dim_; + std::tuple...> atts_; + + std::tuple&> dimensions() const { + return std::tuple&>(dim_); + } + + std::tuple&...> attributes() const { + return std::apply( + [](const std::vector&... attribute) { + return std::tuple&...>(attribute...); + }, + atts_); + } }; /** @@ -122,9 +145,22 @@ struct Fragment1D { */ template struct Fragment2D { - std::vector d1; - std::vector d2; - std::tuple...> atts; + std::vector d1_; + std::vector d2_; + std::tuple...> atts_; + + std::tuple&, const std::vector&> dimensions() + const { + return std::tuple&, const std::vector&>(d1_, d2_); + } + + std::tuple&...> attributes() const { + return std::apply( + [](const std::vector&... attribute) { + return std::tuple&...>(attribute...); + }, + atts_); + } }; } // namespace tiledb::test::tdbrc @@ -212,15 +248,17 @@ Gen make_extent(const Domain& domain) { return gen::inRange(extent_lower_bound, extent_upper_bound + 1); } -template +template struct Arbitrary> { static Gen> arbitrary() { - auto tup = gen::mapcat(gen::arbitrary>(), [](Domain domain) { - return gen::pair(gen::just(domain), make_extent(domain)); - }); - - return gen::map(tup, [](std::pair, D> tup) { - return Dimension{.domain = tup.first, .extent = tup.second}; + using CoordType = Dimension::value_type; + auto tup = gen::mapcat( + gen::arbitrary>(), [](Domain domain) { + return gen::pair(gen::just(domain), make_extent(domain)); + }); + + return gen::map(tup, [](std::pair, CoordType> tup) { + return Dimension{.domain = tup.first, .extent = tup.second}; }); } }; @@ -277,7 +315,7 @@ Gen> make_fragment_1d(const Domain& d) { }, stdx::transpose(cells)); - return Fragment1D{.dim = coords, .atts = atts}; + return Fragment1D{.dim_ = coords, .atts_ = atts}; }); } From 383991d9c0a2dc15426f8c5ae7a338f182715b46 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 23 Dec 2024 20:56:23 -0500 Subject: [PATCH 074/228] Generic expectcoords, expectatts --- test/src/unit-sparse-global-order-reader.cc | 55 +++++++++++------- test/support/rapidcheck/array.h | 62 +++++++++++++++++++++ 2 files changed, 98 insertions(+), 19 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 2762d83a50b..ec94e81ee61 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -81,10 +81,22 @@ struct FxFragment1D { std::vector coords; std::vector atts; + uint64_t size() const { + return coords.size(); + } + + std::tuple&> dimensions() { + return std::tuple&>(coords); + } + std::tuple&> dimensions() const { return std::tuple&>(coords); } + std::tuple&> attributes() { + return std::tuple&>(atts); + } + std::tuple&> attributes() const { return std::tuple&>(atts); } @@ -142,10 +154,11 @@ struct FxRun1D { DefaultArray1DConfig array; MemoryBudget memory; - bool accept_coord(int coord) const { + bool accept(const FxFragment1D& fragment, int record) const { if (subarray.empty()) { return true; } else { + const int coord = fragment.coords[record]; for (const auto& range : subarray) { if (range.contains(coord)) { return true; @@ -219,6 +232,7 @@ struct CApiArray { template concept InstanceType = requires(const T& instance) { instance.fragments; + instance.subarray; instance.dimensions(); instance.attributes(); }; @@ -2348,32 +2362,35 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { write_fragment(fragment); } - std::vector expectcoords; - std::vector expectatts; + std::decay_t expect; for (const auto& fragment : instance.fragments) { + auto expect_dimensions = expect.dimensions(); + auto expect_attributes = expect.attributes(); + if (instance.subarray.empty()) { - expectcoords.reserve(expectcoords.size() + fragment.coords.size()); - expectatts.reserve(expectatts.size() + fragment.atts.size()); - expectcoords.insert( - expectcoords.end(), fragment.coords.begin(), fragment.coords.end()); - expectatts.insert( - expectatts.end(), fragment.atts.begin(), fragment.atts.end()); + stdx::extend(expect_dimensions, fragment.dimensions()); + stdx::extend(expect_attributes, fragment.attributes()); } else { - std::vector passing_idxs; - for (uint64_t i = 0; i < fragment.coords.size(); i++) { - if (instance.accept_coord(fragment.coords[i])) { - passing_idxs.push_back(i); + std::vector accept; + for (uint64_t i = 0; i < fragment.size(); i++) { + if (instance.accept(fragment, i)) { + accept.push_back(i); } } - expectcoords.reserve(expectcoords.size() + passing_idxs.size()); - expectatts.reserve(expectatts.size() + passing_idxs.size()); - for (const uint64_t i : passing_idxs) { - expectcoords.push_back(fragment.coords[i]); - expectatts.push_back(fragment.atts[i]); - } + const auto fdimensions = + stdx::select(fragment.dimensions(), std::span(accept)); + const auto fattributes = + stdx::select(fragment.attributes(), std::span(accept)); + stdx::extend(expect_dimensions, stdx::reference_tuple(fdimensions)); + stdx::extend(expect_attributes, stdx::reference_tuple(fattributes)); } } + std::vector expectcoords; + std::vector expectatts; + std::tie(expectcoords) = expect.dimensions(); + std::tie(expectatts) = expect.attributes(); + // sort for naive comparison { std::vector idxs(expectcoords.size()); diff --git a/test/support/rapidcheck/array.h b/test/support/rapidcheck/array.h index 5f4ffb45e5a..d19ee1b62cb 100644 --- a/test/support/rapidcheck/array.h +++ b/test/support/rapidcheck/array.h @@ -42,6 +42,7 @@ #include #include +#include #include namespace tiledb::test::tdbrc { @@ -66,6 +67,8 @@ concept AttributeType = template concept FragmentType = requires(const T& fragment) { + { fragment.size() } -> std::convertible_to; + // not sure how to specify "returns any tuple whose elements decay to // std::vector" fragment.dimensions(); @@ -127,6 +130,10 @@ struct Fragment1D { std::vector dim_; std::tuple...> atts_; + uint64_t size() const { + return dim_.size(); + } + std::tuple&> dimensions() const { return std::tuple&>(dim_); } @@ -149,6 +156,10 @@ struct Fragment2D { std::vector d2_; std::tuple...> atts_; + uint64_t size() const { + return d1_.size(); + } + std::tuple&, const std::vector&> dimensions() const { return std::tuple&, const std::vector&>(d1_, d2_); @@ -188,6 +199,57 @@ std::tuple...> transpose(std::vector> rows) { return cols; } +template +std::tuple reference_tuple(const std::tuple& tuple) { + return std::apply( + [](const Ts&... field) { return std::forward_as_tuple(field...); }, + tuple); +} + +template +void extend( + std::tuple&...>& dest, + std::tuple&...> src) { + std::apply( + [&](std::vector&... dest_col) { + std::apply( + [&](const std::vector&... src_col) { + (dest_col.reserve(dest_col.size() + src_col.size()), ...); + (dest_col.insert(dest_col.end(), src_col.begin(), src_col.end()), + ...); + }, + src); + }, + dest); +} + +template +std::tuple...> select( + std::tuple&...> records, + std::span idxs) { + std::tuple...> selected; + + auto select_into = [&idxs]( + std::vector& dest, std::span src) { + dest.reserve(idxs.size()); + for (auto i : idxs) { + dest.push_back(src[i]); + } + }; + + std::apply( + [&](std::vector&... sel) { + std::apply( + [&](const std::vector&... col) { + (select_into.template operator()(sel, std::span(col)), ...); + }, + records); + }, + selected); + + return selected; +} + } // namespace stdx namespace rc { From 40cd0a87a0a83370a51eb0fae359a847b2a7f185 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 23 Dec 2024 20:58:06 -0500 Subject: [PATCH 075/228] Fix types to auto --- test/src/unit-sparse-global-order-reader.cc | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index ec94e81ee61..b343c3459f7 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -502,8 +502,8 @@ void CSparseGlobalOrderFx::write_fragment(const Fragment& fragment) { // Open array for writing. CApiArray array(ctx_, array_name_.c_str(), TILEDB_WRITE); - const std::tuple&> dimensions = fragment.dimensions(); - const std::tuple&> attributes = fragment.attributes(); + const auto dimensions = fragment.dimensions(); + const auto attributes = fragment.attributes(); // make field size locations std::optional num_cells; @@ -518,13 +518,13 @@ void CSparseGlobalOrderFx::write_fragment(const Fragment& fragment) { return field_size; }; - std::tuple dimension_sizes = std::apply( + auto dimension_sizes = std::apply( [make_field_size](const std::vector&... dimension) { return std::make_tuple(make_field_size(dimension)...); }, dimensions); - std::tuple attribute_sizes = std::apply( + auto attribute_sizes = std::apply( [make_field_size](const std::vector&... attribute) { return std::make_tuple(make_field_size(attribute)...); }, From f61f7c560bd2190b260255191c57b26fce15f2e1 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 23 Dec 2024 21:23:53 -0500 Subject: [PATCH 076/228] Generic sort for naive comparison --- test/src/unit-sparse-global-order-reader.cc | 36 +++++++++++---------- test/support/rapidcheck/array.h | 7 ++-- 2 files changed, 24 insertions(+), 19 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index b343c3459f7..b525f5a0b51 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2386,31 +2386,33 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { } } - std::vector expectcoords; - std::vector expectatts; - std::tie(expectcoords) = expect.dimensions(); - std::tie(expectatts) = expect.attributes(); - // sort for naive comparison { - std::vector idxs(expectcoords.size()); + std::vector idxs(expect.size()); std::iota(idxs.begin(), idxs.end(), 0); - std::sort(idxs.begin(), idxs.end(), [&](int ia, int ib) -> bool { - return expectcoords[ia] < expectcoords[ib]; + std::sort(idxs.begin(), idxs.end(), [&](uint64_t ia, uint64_t ib) -> bool { + return std::apply( + [ia, ib](const std::vector&... dims) { + const auto l = {dims[ia]...}; + const auto r = {dims[ib]...}; + return std::lexicographical_compare( + l.begin(), l.end(), r.begin(), r.end()); + }, + expect.dimensions()); }); - std::vector sortatts; - sortatts.reserve(idxs.size()); - for (const auto i : idxs) { - sortatts.push_back(expectatts[i]); - } - RCCATCH_REQUIRE(sortatts.size() == expectatts.size()); - expectatts = sortatts; - - std::sort(expectcoords.begin(), expectcoords.end()); + expect.dimensions() = stdx::select( + stdx::reference_tuple(expect.dimensions()), std::span(idxs)); + expect.attributes() = stdx::select( + stdx::reference_tuple(expect.attributes()), std::span(idxs)); } + std::vector expectcoords; + std::vector expectatts; + std::tie(expectcoords) = expect.dimensions(); + std::tie(expectatts) = expect.attributes(); + // Open array for reading. CApiArray array(ctx_, array_name_.c_str(), TILEDB_READ); diff --git a/test/support/rapidcheck/array.h b/test/support/rapidcheck/array.h index d19ee1b62cb..46b0c30a7e5 100644 --- a/test/support/rapidcheck/array.h +++ b/test/support/rapidcheck/array.h @@ -200,9 +200,12 @@ std::tuple...> transpose(std::vector> rows) { } template -std::tuple reference_tuple(const std::tuple& tuple) { +std::tuple&...> reference_tuple( + const std::tuple& tuple) { return std::apply( - [](const Ts&... field) { return std::forward_as_tuple(field...); }, + [](const std::decay_t&... field) { + return std::forward_as_tuple(field...); + }, tuple); } From b04b5e06d74fd9c97af8e996d14fb05a0ffe65e0 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 24 Dec 2024 16:02:24 -0500 Subject: [PATCH 077/228] Genericize query loop --- test/src/unit-sparse-global-order-reader.cc | 274 ++++++++++++-------- 1 file changed, 167 insertions(+), 107 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index b525f5a0b51..9f5e3fe22a1 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -317,13 +317,13 @@ struct CSparseGlobalOrderFx { } while (0) template -std::string CSparseGlobalOrderFx::error_if_any(CAPIReturn apirc) const { +std::string error_if_any(tiledb_ctx_t* ctx, CAPIReturn apirc) { if (apirc == TILEDB_OK) { return ""; } tiledb_error_t* error = NULL; - auto rc = tiledb_ctx_get_last_error(ctx_, &error); + auto rc = tiledb_ctx_get_last_error(ctx, &error); REQUIRE(rc == TILEDB_OK); if (error == nullptr) { // probably should be unreachable @@ -337,6 +337,11 @@ std::string CSparseGlobalOrderFx::error_if_any(CAPIReturn apirc) const { return std::string(msg); } +template +std::string CSparseGlobalOrderFx::error_if_any(CAPIReturn apirc) const { + return ::error_if_any(ctx_, apirc); +} + CSparseGlobalOrderFx::CSparseGlobalOrderFx() { reset_config(); @@ -497,6 +502,89 @@ void CSparseGlobalOrderFx::write_1d_fragment( tiledb_query_free(&query); } +template +struct query_applicator { + static auto make_field_sizes( + const std::tuple fields, + uint64_t cell_limit = std::numeric_limits::max()) { + std::optional num_cells; + auto make_field_size = [&](const std::vector& field) { + const uint64_t field_cells = std::min(cell_limit, field.size()); + const uint64_t field_size = field_cells * sizeof(T); + if (num_cells.has_value()) { + // precondition: each field must have the same number of cells + RCCATCH_REQUIRE(field_cells == num_cells.value()); + } else { + num_cells.emplace(field_cells); + } + return field_size; + }; + + return std::apply( + [make_field_size](const auto&... field) { + return std::make_tuple(make_field_size(field)...); + }, + fields); + } + + static void set( + tiledb_ctx_t* ctx, + tiledb_query_t* query, + auto& field_sizes, + std::tuple fields, + const char* basename, + uint64_t cell_offset = 0) { + auto set_data_buffer = + [&](const std::string& name, auto& field, uint64_t& field_size) { + auto ptr = const_cast( + static_cast(&field.data()[cell_offset])); + auto rc = tiledb_query_set_data_buffer( + ctx, query, name.c_str(), ptr, &field_size); + RCCATCH_REQUIRE("" == error_if_any(ctx, rc)); + }; + + uint64_t d = 1; + std::apply( + [&](const auto&... field) { + std::apply( + [&](Us&... field_size) { + (set_data_buffer( + basename + std::to_string(d++), field, field_size), + ...); + }, + field_sizes); + }, + fields); + } + + static uint64_t num_cells(const auto& fields, const auto& field_sizes) { + std::optional num_cells; + + auto check_field = [&]( + const std::vector& field, uint64_t field_size) { + RCCATCH_REQUIRE(field_size % sizeof(T) == 0); + RCCATCH_REQUIRE(field_size <= field.size() * sizeof(T)); + if (num_cells.has_value()) { + RCCATCH_REQUIRE(num_cells.value() == field_size / sizeof(T)); + } else { + num_cells.emplace(field_size / sizeof(T)); + } + }; + + std::apply( + [&](const auto&... field) { + std::apply( + [&](const auto&... field_size) { + (check_field(field, field_size), ...); + }, + field_sizes); + }, + fields); + + return num_cells.value(); + } +}; + template void CSparseGlobalOrderFx::write_fragment(const Fragment& fragment) { // Open array for writing. @@ -506,29 +594,12 @@ void CSparseGlobalOrderFx::write_fragment(const Fragment& fragment) { const auto attributes = fragment.attributes(); // make field size locations - std::optional num_cells; - auto make_field_size = [&num_cells](const std::vector& field) { - const uint64_t field_size = field.size() * sizeof(T); - if (num_cells.has_value()) { - // precondition: each field must have the same number of cells - RCCATCH_REQUIRE(field.size() == num_cells.value()); - } else { - num_cells.emplace(field.size()); - } - return field_size; - }; - - auto dimension_sizes = std::apply( - [make_field_size](const std::vector&... dimension) { - return std::make_tuple(make_field_size(dimension)...); - }, - dimensions); - - auto attribute_sizes = std::apply( - [make_field_size](const std::vector&... attribute) { - return std::make_tuple(make_field_size(attribute)...); - }, - attributes); + auto dimension_sizes = [](std::tuple dimensions) { + return query_applicator::make_field_sizes(dimensions); + }(dimensions); + auto attribute_sizes = [](std::tuple attributes) { + return query_applicator::make_field_sizes(attributes); + }(attributes); // Create the query. tiledb_query_t* query; @@ -537,70 +608,33 @@ void CSparseGlobalOrderFx::write_fragment(const Fragment& fragment) { rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); RCCATCH_REQUIRE(rc == TILEDB_OK); - auto set_data_buffer = [this, query]( - const std::string& name, - const std::vector& field, - uint64_t& field_size) { - auto rc = tiledb_query_set_data_buffer( - ctx_, query, name.c_str(), const_cast(field.data()), &field_size); - RCCATCH_REQUIRE("" == error_if_any(rc)); - }; - // add dimensions to query - uint64_t d = 1; - std::apply( - [&](const std::vector&... dimension) { - std::apply( - [&](Us&... dimension_size) { - (set_data_buffer( - "d" + std::to_string(d++), dimension, dimension_size), - ...); - }, - dimension_sizes); - }, - dimensions); + [&](std::tuple dims) { + query_applicator::set( + ctx_, query, dimension_sizes, dims, "d"); + }(dimensions); // add attributes to query - uint64_t a = 1; - std::apply( - [&](const std::vector&... attribute) { - std::apply( - [&](Us&... attribute_size) { - (set_data_buffer( - "a" + std::to_string(a++), attribute, attribute_size), - ...); - }, - attribute_sizes); - }, - attributes); + [&](std::tuple atts) { + query_applicator::set( + ctx_, query, attribute_sizes, atts, "a"); + }(attributes); // Submit query. rc = tiledb_query_submit(ctx_, query); RCCATCH_REQUIRE("" == error_if_any(rc)); // check that sizes match what we expect - auto require_full_write = - [](const std::vector& field, uint64_t write_size) { - RCCATCH_REQUIRE(write_size == field.size() * sizeof(T)); - }; - std::apply( - [&](const std::vector&... dimension) { - std::apply( - [&](const Us&... dimension_size) { - (require_full_write(dimension, dimension_size), ...); - }, - dimension_sizes); - }, - dimensions); - std::apply( - [&](const std::vector&... attribute) { - std::apply( - [&](const Us&... attribute_size) { - (require_full_write(attribute, attribute_size), ...); - }, - attribute_sizes); - }, - attributes); + const uint64_t expect_num_cells = fragment.size(); + const uint64_t dim_num_cells = [&](auto dims) { + return query_applicator::num_cells(dims, dimension_sizes); + }(dimensions); + const uint64_t att_num_cells = [&](auto atts) { + return query_applicator::num_cells(atts, attribute_sizes); + }(attributes); + + RCCATCH_REQUIRE(dim_num_cells == expect_num_cells); + RCCATCH_REQUIRE(att_num_cells == expect_num_cells); // Clean up. tiledb_query_free(&query); @@ -2435,25 +2469,38 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { } // Prepare output buffer - std::vector outcoords; - std::vector outatts; - for (const auto& fragment : instance.fragments) { - outcoords.resize(outcoords.size() + fragment.coords.size(), 0); - outatts.resize(outatts.size() + fragment.atts.size(), 0); - } + std::decay_t out; + + auto outdims = out.dimensions(); + auto outatts = out.attributes(); + std::apply( + [&](auto&... field) { + (field.resize(std::max(1UL, expectcoords.size()), 0), ...); + }, + std::tuple_cat(outdims, outatts)); + // Query loop uint64_t outcursor = 0; while (true) { - uint64_t outcoords_size; - uint64_t outatts_size; - outcoords_size = outatts_size = instance.num_user_cells * sizeof(int); - - rc = tiledb_query_set_data_buffer( - ctx_, query, "a1", &outatts[outcursor], &outatts_size); - RCCATCH_REQUIRE("" == error_if_any(rc)); - rc = tiledb_query_set_data_buffer( - ctx_, query, "d1", &outcoords[outcursor], &outcoords_size); - RCCATCH_REQUIRE("" == error_if_any(rc)); + // make field size locations + auto dimension_sizes = [&](std::tuple outdims) { + return query_applicator::make_field_sizes( + outdims, instance.num_user_cells); + }(outdims); + auto attribute_sizes = [&](std::tuple outdims) { + return query_applicator::make_field_sizes( + outdims, instance.num_user_cells); + }(outatts); + + // add fields to query + [&](std::tuple dims) { + query_applicator::set( + ctx_, query, dimension_sizes, dims, "d", outcursor); + }(outdims); + [&](std::tuple atts) { + query_applicator::set( + ctx_, query, attribute_sizes, atts, "a", outcursor); + }(outatts); rc = tiledb_query_submit(ctx_, query); { @@ -2473,16 +2520,24 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { rc = tiledb_query_get_status(ctx_, query, &status); RCCATCH_REQUIRE(rc == TILEDB_OK); - if (outcoords_size < instance.num_user_cells * sizeof(int)) { + const uint64_t dim_num_cells = [&](auto dims) { + return query_applicator::num_cells( + dims, dimension_sizes); + }(outdims); + const uint64_t att_num_cells = [&](auto atts) { + return query_applicator::num_cells( + atts, attribute_sizes); + }(outatts); + + RCCATCH_REQUIRE(dim_num_cells == att_num_cells); + + if (dim_num_cells < instance.num_user_cells) { RCCATCH_REQUIRE(status == TILEDB_COMPLETED); } else { - RCCATCH_REQUIRE(outcoords_size == instance.num_user_cells * sizeof(int)); + RCCATCH_REQUIRE(dim_num_cells == instance.num_user_cells); } - RCCATCH_REQUIRE(outcoords_size % sizeof(int) == 0); - outcursor += outcoords_size / sizeof(int); - // since they are the same data type - RCCATCH_REQUIRE(outatts_size == outcoords_size); + outcursor += dim_num_cells; if (status == TILEDB_COMPLETED) { break; @@ -2492,15 +2547,20 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { // Clean up. tiledb_query_free(&query); - outcoords.resize(outcursor); - outatts.resize(outcursor); + std::apply( + [outcursor](auto&... outfield) { (outfield.resize(outcursor), ...); }, + std::tuple_cat(outdims, outatts)); + + std::vector outcoords, outa1; + std::tie(outcoords) = outdims; + std::tie(outa1) = outatts; - RCCATCH_REQUIRE(expectcoords == outcoords); + RCCATCH_REQUIRE(expect.dimensions() == out.dimensions()); // Checking attributes is more complicated because equal coords // can manifest their attributes in any order. // Identify the runs of equal coords and then compare using those - RCCATCH_REQUIRE(expectatts.size() == outatts.size()); + RCCATCH_REQUIRE(expectatts.size() == outa1.size()); int attcursor = 0; int runlength = 1; for (size_t i = 1; i < expectcoords.size(); i++) { @@ -2511,7 +2571,7 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { expectatts.begin() + attcursor, expectatts.begin() + attcursor + runlength); std::set outattsrun( - outatts.begin() + attcursor, outatts.begin() + attcursor + runlength); + outa1.begin() + attcursor, outa1.begin() + attcursor + runlength); RCCATCH_REQUIRE(expectattsrun == outattsrun); attcursor += runlength; runlength = 1; From 80916349f0e0226c065ffcef8b92acc501afdb3f Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Sun, 29 Dec 2024 11:48:12 -0500 Subject: [PATCH 078/228] Genericize expectatts check --- test/src/unit-sparse-global-order-reader.cc | 37 ++++++++++++++------- 1 file changed, 25 insertions(+), 12 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 9f5e3fe22a1..c164bc3a1b6 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2555,24 +2555,37 @@ void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { std::tie(outcoords) = outdims; std::tie(outa1) = outatts; - RCCATCH_REQUIRE(expect.dimensions() == out.dimensions()); + RCCATCH_REQUIRE(expect.dimensions() == outdims); // Checking attributes is more complicated because equal coords // can manifest their attributes in any order. // Identify the runs of equal coords and then compare using those - RCCATCH_REQUIRE(expectatts.size() == outa1.size()); - int attcursor = 0; - int runlength = 1; - for (size_t i = 1; i < expectcoords.size(); i++) { - if (expectcoords[i] == expectcoords[i - 1]) { + size_t attcursor = 0; + size_t runlength = 1; + for (size_t i = 1; i < out.size(); i++) { + if (std::apply( + [&](const auto&... outdim) { + return (... && (outdim[i] == outdim[i - 1])); + }, + outdims)) { runlength++; } else { - std::set expectattsrun( - expectatts.begin() + attcursor, - expectatts.begin() + attcursor + runlength); - std::set outattsrun( - outa1.begin() + attcursor, outa1.begin() + attcursor + runlength); - RCCATCH_REQUIRE(expectattsrun == outattsrun); + auto viewtuple = [&](const auto& atttuple, size_t i) { + return std::apply( + [&](const auto&... att) { return std::make_tuple(att[i]...); }, + atttuple); + }; + + std::set outattsrun; + std::set expectattsrun; + + for (size_t j = attcursor; j < attcursor + runlength; j++) { + outattsrun.insert(viewtuple(outatts, j)); + expectattsrun.insert(viewtuple(expect.attributes(), j)); + } + + RCCATCH_REQUIRE(outattsrun == expectattsrun); + attcursor += runlength; runlength = 1; } From 04aab6c7485c7b2540ed7182dc6218855bc4c56c Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Sun, 29 Dec 2024 11:53:30 -0500 Subject: [PATCH 079/228] run_1d => run --- test/src/unit-sparse-global-order-reader.cc | 22 ++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index c164bc3a1b6..b37bf7e6d3e 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -141,7 +141,7 @@ struct DefaultArray1DConfig { }; /** - * An instance of input to `CSparseGlobalOrderFx::run_1d` + * An instance of one-dimension array input to `CSparseGlobalOrderFx::run` */ struct FxRun1D { uint64_t num_user_cells; @@ -296,12 +296,12 @@ struct CSparseGlobalOrderFx { void create_array(const Instance& instance); /** - * Runs an input against a fresh 1D array. + * Runs an input against a fresh array. * Inserts fragments one at a time, then reads them back in global order * and checks that what we read out matches what we put in. */ - template - void run_1d(FxRun1D instance); + template + void run(Instance instance); template std::string error_if_any(CAPIReturn apirc) const; @@ -1282,7 +1282,7 @@ TEST_CASE_METHOD( instance.subarray = subarray; - run_1d(instance); + run(instance); }; SECTION("Example") { @@ -1354,7 +1354,7 @@ TEST_CASE_METHOD( instance.memory.ratio_array_data_ = "0.5"; instance.array.allow_dups = true; - run_1d(instance); + run(instance); }; SECTION("Example") { @@ -1448,7 +1448,7 @@ TEST_CASE_METHOD( instance.num_user_cells = num_user_cells; - run_1d(instance); + run(instance); }; SECTION("Example") { @@ -2378,8 +2378,8 @@ void CSparseGlobalOrderFx::create_array(const Instance& instance) { instance.array.allow_dups); } -template -void CSparseGlobalOrderFx::run_1d(FxRun1D instance) { +template +void CSparseGlobalOrderFx::run(Instance instance) { RCCATCH_REQUIRE(instance.num_user_cells > 0); reset_config(); @@ -2719,7 +2719,7 @@ TEST_CASE_METHOD( "[sparse-global-order]") { SECTION("Rapidcheck") { rc::prop("rapidcheck arbitrary 1d", [this](FxRun1D instance) { - run_1d(instance); + run(instance); }); } } @@ -2745,7 +2745,7 @@ TEST_CASE_METHOD( // NB: `Rapidcheck` just throws a normal exception, // we are not actually in a rapidcheck context. - REQUIRE_THROWS(run_1d(instance)); + REQUIRE_THROWS(run(instance)); tiledb_error_t* error = NULL; auto rc = tiledb_ctx_get_last_error(ctx_, &error); From 53cfd7d5e6dab80c3cabe461886b65b6d70af3f4 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Sun, 29 Dec 2024 22:05:41 -0500 Subject: [PATCH 080/228] Genericize can_complete_in_memory_budget --- test/src/unit-sparse-global-order-reader.cc | 38 +++++++++++++-------- 1 file changed, 23 insertions(+), 15 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index b37bf7e6d3e..71a856fd4af 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -168,6 +168,17 @@ struct FxRun1D { } } + bool intersects(const sm::NDRange& mbr) const { + auto accept = [&](const auto& range) { + const auto& untyped_mbr = mbr[0]; + const tdbrc::Domain typed_mbr( + untyped_mbr.start_as(), untyped_mbr.end_as()); + return range.intersects(typed_mbr); + }; + return subarray.empty() || + std::any_of(subarray.begin(), subarray.end(), accept); + } + std::tuple&> dimensions() const { return std::tuple&>( array.dimension); @@ -867,8 +878,9 @@ int32_t CSparseGlobalOrderFx::read_strings( * * *there are ways to get around this but they are not implemented. */ +template static bool can_complete_in_memory_budget( - tiledb_ctx_t* ctx, const char* array_uri, const FxRun1D& instance) { + tiledb_ctx_t* ctx, const char* array_uri, const Instance& instance) { CApiArray array(ctx, array_uri, TILEDB_READ); // TODO: verify that the conditions for the error are correct @@ -881,7 +893,15 @@ static bool can_complete_in_memory_budget( auto tiles_size = [&](unsigned f, uint64_t t) { using BitmapType = uint8_t; - const size_t data_size = fragment_metadata[f]->tile_size("d1", t); + + size_t data_size = 0; + for (size_t d = 0; + d < std::tuple_size::value; + d++) { + data_size += + fragment_metadata[f]->tile_size("d" + std::to_string(d + 1), t); + } + const size_t rt_size = sizeof(sm::GlobalOrderResultTile); const size_t subarray_size = (instance.subarray.empty() ? @@ -945,21 +965,9 @@ static bool can_complete_in_memory_budget( mbr_lower_bound(cmp_pq_lower_bound); for (unsigned f = 0; f < instance.fragments.size(); f++) { for (uint64_t t = 0; t < fragment_metadata[f]->tile_num(); t++) { - if (instance.subarray.empty()) { + if (instance.intersects(fragment_metadata[f]->mbr(t))) { mbr_lower_bound.push( sm::ResultTileId{.fragment_idx_ = f, .tile_idx_ = t}); - } else { - auto accept = [&](const auto& range) { - const auto& untyped_mbr = fragment_metadata[f]->mbr(t)[0]; - const tdbrc::Domain typed_mbr( - untyped_mbr.start_as(), untyped_mbr.end_as()); - return range.intersects(typed_mbr); - }; - if (std::any_of( - instance.subarray.begin(), instance.subarray.end(), accept)) { - mbr_lower_bound.push( - sm::ResultTileId{.fragment_idx_ = f, .tile_idx_ = t}); - } } } } From d58c92abe6718c46e366ba73d39b7b6b3894b1f4 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 30 Dec 2024 08:39:19 -0500 Subject: [PATCH 081/228] FxRun2D instantiation compiles --- test/src/unit-sparse-global-order-reader.cc | 304 +++++++++++++++++--- test/support/rapidcheck/array.h | 18 +- 2 files changed, 283 insertions(+), 39 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 71a856fd4af..7c84ab7b9ec 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -69,6 +69,14 @@ Gen>> make_subarray_1d( const tdbrc::Domain& domain); } +#define RETURN_IF_ERR(thing) \ + do { \ + auto rc = (thing); \ + if (rc != TILEDB_OK) { \ + return rc; \ + } \ + } while (0) + /* ********************************* */ /* STRUCT DEFINITION */ /* ********************************* */ @@ -144,8 +152,9 @@ struct DefaultArray1DConfig { * An instance of one-dimension array input to `CSparseGlobalOrderFx::run` */ struct FxRun1D { + using FragmentType = FxFragment1D; uint64_t num_user_cells; - std::vector fragments; + std::vector fragments; // NB: for now this always has length 1, global order query does not // support multi-range subarray @@ -154,7 +163,25 @@ struct FxRun1D { DefaultArray1DConfig array; MemoryBudget memory; - bool accept(const FxFragment1D& fragment, int record) const { + uint64_t tile_capacity() const { + return array.capacity; + } + + bool allow_duplicates() const { + return array.allow_dups; + } + + template + capi_return_t apply_subarray( + tiledb_ctx_t* ctx, tiledb_subarray_t* subarray) const { + for (const auto& range : this->subarray) { + RETURN_IF_ERR(tiledb_subarray_add_range( + ctx, subarray, 0, &range.lower_bound, &range.upper_bound, nullptr)); + } + return TILEDB_OK; + } + + bool accept(const FragmentType& fragment, int record) const { if (subarray.empty()) { return true; } else { @@ -179,6 +206,20 @@ struct FxRun1D { std::any_of(subarray.begin(), subarray.end(), accept); } + sm::NDRange clamp(const sm::NDRange& mbr) const { + if (subarray.empty()) { + return mbr; + } + assert(subarray.size() == 1); + if (subarray[0].upper_bound < mbr[0].end_as()) { + // in this case, the bitmap will filter out the other coords in the + // tile and it will be discarded + return std::vector{subarray[0].range()}; + } else { + return mbr; + } + } + std::tuple&> dimensions() const { return std::tuple&>( array.dimension); @@ -189,6 +230,155 @@ struct FxRun1D { } }; +struct FxRun2D { + using Coord0Type = int; + using Coord1Type = int; + using FragmentType = tdbrc::Fragment2D; + + std::vector fragments; + std::vector>, + std::optional>>> + subarray; + + size_t num_user_cells; + + uint64_t capacity; + bool allow_dups; + tdbrc::Dimension d1; + tdbrc::Dimension d2; + + MemoryBudget memory; + + FxRun2D() + : num_user_cells(8) + , capacity(64) + , allow_dups(true) { + d1.domain = tdbrc::Domain(1, 200); + d1.extent = 8; + d2.domain = tdbrc::Domain(1, 200); + d2.extent = 8; + } + + uint64_t tile_capacity() const { + return capacity; + } + + bool allow_duplicates() const { + return allow_dups; + } + + template + capi_return_t apply_subarray( + tiledb_ctx_t* ctx, tiledb_subarray_t* subarray) const { + for (const auto& range : this->subarray) { + if (range.first.has_value()) { + RETURN_IF_ERR(tiledb_subarray_add_range( + ctx, + subarray, + 0, + &range.first->lower_bound, + &range.first->upper_bound, + nullptr)); + } else { + RETURN_IF_ERR(tiledb_subarray_add_range( + ctx, + subarray, + 0, + &d1.domain.lower_bound, + &d1.domain.upper_bound, + nullptr)); + } + if (range.second.has_value()) { + RETURN_IF_ERR(tiledb_subarray_add_range( + ctx, + subarray, + 1, + &range.second->lower_bound, + &range.second->upper_bound, + nullptr)); + } else { + RETURN_IF_ERR(tiledb_subarray_add_range( + ctx, + subarray, + 1, + &d2.domain.lower_bound, + &d2.domain.upper_bound, + nullptr)); + } + } + return TILEDB_OK; + } + + bool accept(const FragmentType& fragment, int record) const { + if (subarray.empty()) { + return true; + } else { + const int r = fragment.d1_[record], c = fragment.d2_[record]; + for (const auto& range : subarray) { + if (range.first.has_value() && !range.first->contains(r)) { + continue; + } else if (range.second.has_value() && !range.second->contains(c)) { + continue; + } else { + return true; + } + } + return false; + } + } + + bool intersects(const sm::NDRange& mbr) const { + if (subarray.empty()) { + return true; + } + + const tdbrc::Domain typed_domain0( + mbr[0].start_as(), mbr[0].end_as()); + const tdbrc::Domain typed_domain1( + mbr[1].start_as(), mbr[1].end_as()); + + for (const auto& range : subarray) { + if (range.first.has_value() && !range.first->intersects(typed_domain0)) { + continue; + } else if ( + range.second.has_value() && + !range.second->intersects(typed_domain1)) { + continue; + } else { + return true; + } + } + return false; + } + + sm::NDRange clamp(const sm::NDRange& mbr) const { + sm::NDRange clamped = mbr; + for (const auto& range : subarray) { + if (range.first.has_value() && + range.first->upper_bound < clamped[0].end_as()) { + clamped[0].set_end_fixed(&range.first->upper_bound); + } + if (range.second.has_value() && + range.second->upper_bound < clamped[1].end_as()) { + clamped[1].set_end_fixed(&range.second->upper_bound); + } + } + return clamped; + } + + using CoordsRefType = std::tuple< + const tdbrc::Dimension&, + const tdbrc::Dimension&>; + CoordsRefType dimensions() const { + return CoordsRefType(d1, d2); + } + + std::tuple attributes() const { + return std::make_tuple(Datatype::INT32); + } +}; + /** * RAII to make sure we close our arrays so that keeping the same array URI * open from one test to the next doesn't muck things up @@ -242,10 +432,18 @@ struct CApiArray { template concept InstanceType = requires(const T& instance) { + { instance.tile_capacity() } -> std::convertible_to; + { instance.allow_duplicates() } -> std::same_as; + + { instance.num_user_cells } -> std::convertible_to; + instance.fragments; + instance.memory; instance.subarray; instance.dimensions(); instance.attributes(); + + // also `accept(Self::FragmentType, int)`, unclear how to represent that }; struct CSparseGlobalOrderFx { @@ -935,28 +1133,13 @@ static bool can_complete_in_memory_budget( * the entirety of `rtl` before any of `rtr` */ auto cmp_upper_to_lower = [&](const RT& rtl, const RT& rtr) { - const sm::RangeUpperBound l_mbr = { - .mbr = fragment_metadata[rtl.fragment_idx_]->mbr(rtl.tile_idx_)}; + const auto rtl_mbr_clamped = instance.clamp( + fragment_metadata[rtl.fragment_idx_]->mbr(rtl.tile_idx_)); + const sm::RangeUpperBound l_mbr = {.mbr = rtl_mbr_clamped}; const sm::RangeLowerBound r_mbr = { .mbr = fragment_metadata[rtr.fragment_idx_]->mbr(rtr.tile_idx_)}; - int cmp; - if (instance.subarray.empty()) { - cmp = globalcmp.compare(l_mbr, r_mbr); - } else { - assert(instance.subarray.size() == 1); // need to tweak this logic if not - - const auto& subarray = instance.subarray[0]; - if (subarray.upper_bound < *static_cast(l_mbr.coord(0))) { - // in this case, the bitmap will filter out the other coords in the - // tile and it will be discarded - std::vector subarrayrange = {subarray.range()}; - const sm::RangeUpperBound sub_mbr = {.mbr = subarrayrange}; - cmp = globalcmp.compare(sub_mbr, r_mbr); - } else { - cmp = globalcmp.compare(l_mbr, r_mbr); - } - } + const int cmp = globalcmp.compare(l_mbr, r_mbr); return cmp <= 0; }; @@ -1416,7 +1599,7 @@ TEST_CASE_METHOD( */ TEST_CASE_METHOD( CSparseGlobalOrderFx, - "Sparse global order reader: many overlapping fragments", + "Sparse global order reader: fragment wide overlap", "[sparse-global-order]") { auto doit = [this]( size_t num_fragments, @@ -2382,8 +2565,8 @@ void CSparseGlobalOrderFx::create_array(const Instance& instance) { attribute_compressors, TILEDB_ROW_MAJOR, TILEDB_ROW_MAJOR, - instance.array.capacity, - instance.array.allow_dups); + instance.tile_capacity(), + instance.allow_duplicates()); } template @@ -2450,11 +2633,6 @@ void CSparseGlobalOrderFx::run(Instance instance) { stdx::reference_tuple(expect.attributes()), std::span(idxs)); } - std::vector expectcoords; - std::vector expectatts; - std::tie(expectcoords) = expect.dimensions(); - std::tie(expectatts) = expect.attributes(); - // Open array for reading. CApiArray array(ctx_, array_name_.c_str(), TILEDB_READ); @@ -2468,10 +2646,7 @@ void CSparseGlobalOrderFx::run(Instance instance) { if (!instance.subarray.empty()) { tiledb_subarray_t* subarray; TRY(tiledb_subarray_alloc(ctx_, array, &subarray)); - for (const auto& range : instance.subarray) { - TRY(tiledb_subarray_add_range( - ctx_, subarray, 0, &range.lower_bound, &range.upper_bound, nullptr)); - } + TRY(instance.template apply_subarray(ctx_, subarray)); TRY(tiledb_query_set_subarray_t(ctx_, query, subarray)); tiledb_subarray_free(&subarray); } @@ -2483,7 +2658,7 @@ void CSparseGlobalOrderFx::run(Instance instance) { auto outatts = out.attributes(); std::apply( [&](auto&... field) { - (field.resize(std::max(1UL, expectcoords.size()), 0), ...); + (field.resize(std::max(1UL, expect.size()), 0), ...); }, std::tuple_cat(outdims, outatts)); @@ -2559,10 +2734,6 @@ void CSparseGlobalOrderFx::run(Instance instance) { [outcursor](auto&... outfield) { (outfield.resize(outcursor), ...); }, std::tuple_cat(outdims, outatts)); - std::vector outcoords, outa1; - std::tie(outcoords) = outdims; - std::tie(outa1) = outatts; - RCCATCH_REQUIRE(expect.dimensions() == outdims); // Checking attributes is more complicated because equal coords @@ -2673,6 +2844,52 @@ struct Arbitrary { } }; +template <> +struct Arbitrary { + static Gen arbitrary() { + constexpr Datatype Dim0Type = Datatype::INT32; + constexpr Datatype Dim1Type = Datatype::INT32; + using Coord0Type = FxRun2D::Coord0Type; + using Coord1Type = FxRun2D::Coord1Type; + + static_assert(std::is_same_v< + tiledb::type::datatype_traits::value_type, + Coord0Type>); + static_assert(std::is_same_v< + tiledb::type::datatype_traits::value_type, + Coord1Type>); + + auto d0 = gen::arbitrary>(); + auto d1 = gen::arbitrary>(); + + auto fragments = gen::mapcat(gen::pair(d0, d1), [](auto dimensions) { + auto fragment = rc::make_fragment_2d( + dimensions.first.domain, dimensions.second.domain); + return gen::tuple( + gen::just(dimensions.first), + gen::just(dimensions.second), + gen::nonEmpty( + gen::container>(fragment))); + }); + + auto num_user_cells = gen::inRange(1, 8 * 1024 * 1024); + + return gen::apply( + [](auto fragments, int num_user_cells) { + FxRun2D instance; + std::tie(instance.d1, instance.d2, instance.fragments) = fragments; + + // TODO: capacity, subarray + instance.num_user_cells = num_user_cells; + instance.allow_dups = true; + + return instance; + }, + fragments, + num_user_cells); + } +}; + template <> void show(const FxRun1D& instance, std::ostream& os) { size_t f = 0; @@ -2732,6 +2949,17 @@ TEST_CASE_METHOD( } } +TEST_CASE_METHOD( + CSparseGlobalOrderFx, + "Sparse global order reader: rapidcheck 2d", + "[sparse-global-order]") { + SECTION("rapidcheck") { + rc::prop("rapidcheck arbitrary 2d", [this](FxRun2D instance) { + run(instance); + }); + } +} + /** * This test will fail if multi-range subarrays become supported * for global order. diff --git a/test/support/rapidcheck/array.h b/test/support/rapidcheck/array.h index 46b0c30a7e5..bc91fa8792f 100644 --- a/test/support/rapidcheck/array.h +++ b/test/support/rapidcheck/array.h @@ -73,6 +73,10 @@ concept FragmentType = requires(const T& fragment) { // std::vector" fragment.dimensions(); fragment.attributes(); +} and requires(T& fragment) { + // non-const versions + fragment.dimensions(); + fragment.attributes(); }; /** @@ -165,6 +169,10 @@ struct Fragment2D { return std::tuple&, const std::vector&>(d1_, d2_); } + std::tuple&, std::vector&> dimensions() { + return std::tuple&, std::vector&>(d1_, d2_); + } + std::tuple&...> attributes() const { return std::apply( [](const std::vector&... attribute) { @@ -172,6 +180,14 @@ struct Fragment2D { }, atts_); } + + std::tuple&...> attributes() { + return std::apply( + [](std::vector&... attribute) { + return std::tuple&...>(attribute...); + }, + atts_); + } }; } // namespace tiledb::test::tdbrc @@ -410,7 +426,7 @@ Gen> make_fragment_2d( stdx::transpose(cells)); return Fragment2D{ - .d1 = coords_d1, .d2 = coords_d2, .atts = atts}; + .d1_ = coords_d1, .d2_ = coords_d2, .atts_ = atts}; }); } From dab89d06b136fd4a451a212ac8e6c00fc9dc0155 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 30 Dec 2024 09:07:11 -0500 Subject: [PATCH 082/228] Fixed release build unused variable --- tiledb/common/algorithm/parallel_merge.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tiledb/common/algorithm/parallel_merge.cc b/tiledb/common/algorithm/parallel_merge.cc index 51336305f53..61a25d7dd55 100644 --- a/tiledb/common/algorithm/parallel_merge.cc +++ b/tiledb/common/algorithm/parallel_merge.cc @@ -53,7 +53,7 @@ ParallelMergeFuture::~ParallelMergeFuture() { // data which is contractually expected to outlive `this`, // but makes no guarantee after that while (true) { - const auto m = merge_cursor_; + [[maybe_unused]] const auto m = merge_cursor_; try { if (!await().has_value()) { break; From b5bc99c9d38831d9c4a6bf1932b3b0906f9d8fcd Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 30 Dec 2024 10:08:20 -0500 Subject: [PATCH 083/228] ::run exception for 'Cannot load tile offsets' --- test/src/unit-sparse-global-order-reader.cc | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 7c84ab7b9ec..be3894b4fb7 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2694,6 +2694,11 @@ void CSparseGlobalOrderFx::run(Instance instance) { ctx_, array_name_.c_str(), instance)); tiledb_query_free(&query); return; + } else if (err.find("Cannot load tile offsets") != std::string::npos) { + // not enough memory budget for tile offsets, don't bother asserting + // about it (for now?) + tiledb_query_free(&query); + return; } else { RCCATCH_REQUIRE("" == err); } From 8db905b3de557dc83f841160bf4705dfb281157e Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 30 Dec 2024 10:08:46 -0500 Subject: [PATCH 084/228] Apply subarray to rapidcheck 2d --- test/src/unit-sparse-global-order-reader.cc | 28 ++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index be3894b4fb7..2623325575e 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2849,6 +2849,29 @@ struct Arbitrary { } }; +Gen>, + std::optional>>>> +make_subarray_2d(const tdbrc::Domain& d1, const tdbrc::Domain& d2) { + // NB: multi-range subarray is not supported (yet?) for global order read + + return gen::apply( + [](auto d1, auto d2) { + std::optional d1opt; + std::optional d2opt; + if (d1) { + d1opt.emplace(*d1); + } + if (d2) { + d2opt.emplace(*d2); + } + return std::vector>{ + std::make_pair(d1opt, d2opt)}; + }, + gen::maybe(rc::make_range(d1)), + gen::maybe(rc::make_range(d2))); +} + template <> struct Arbitrary { static Gen arbitrary() { @@ -2873,6 +2896,7 @@ struct Arbitrary { return gen::tuple( gen::just(dimensions.first), gen::just(dimensions.second), + make_subarray_2d(dimensions.first.domain, dimensions.second.domain), gen::nonEmpty( gen::container>(fragment))); }); @@ -2882,7 +2906,9 @@ struct Arbitrary { return gen::apply( [](auto fragments, int num_user_cells) { FxRun2D instance; - std::tie(instance.d1, instance.d2, instance.fragments) = fragments; + std::tie( + instance.d1, instance.d2, instance.subarray, instance.fragments) = + fragments; // TODO: capacity, subarray instance.num_user_cells = num_user_cells; From c539acd5a3bbb013f0fe9dd4f931d07800af95a8 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 30 Dec 2024 10:08:58 -0500 Subject: [PATCH 085/228] show --- test/src/unit-sparse-global-order-reader.cc | 59 +++++++++++++++++++++ 1 file changed, 59 insertions(+) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 2623325575e..b6e1f3fa028 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2967,6 +2967,65 @@ void show(const FxRun1D& instance, std::ostream& os) { os << "}"; } +template <> +void show(const FxRun2D& instance, std::ostream& os) { + size_t f = 0; + + os << "{" << std::endl; + os << "\t\"fragments\": [" << std::endl; + for (const auto& fragment : instance.fragments) { + os << "\t\t{" << std::endl; + os << "\t\t\t\"d1\": [" << std::endl; + os << "\t\t\t\t"; + show(fragment.d1_, os); + os << std::endl; + os << "\t\t\t\"d2\": [" << std::endl; + os << "\t\t\t\t"; + show(fragment.d2_, os); + os << std::endl; + os << "\t\t\t], " << std::endl; + os << "\t\t\t\"atts\": [" << std::endl; + os << "\t\t\t\t"; + show(std::get<0>(fragment.atts_), os); + os << std::endl; + os << "\t\t\t] " << std::endl; + os << "\t\t}"; + if ((f++) + 1 < instance.fragments.size()) { + os << ", " << std::endl; + } else { + os << std::endl; + } + } + os << "\t]," << std::endl; + os << "\t\"num_user_cells\": " << instance.num_user_cells << std::endl; + os << "\t\"array\": {" << std::endl; + os << "\t\t\"allow_dups\": " << instance.allow_dups << std::endl; + os << "\t\t\"dimensions\": [" << std::endl; + os << "\t\t\t{" << std::endl; + os << "\t\t\t\t\"domain\": [" << instance.d1.domain.lower_bound << ", " + << instance.d1.domain.upper_bound << "]," << std::endl; + os << "\t\t\t\t\"extent\": " << instance.d1.extent << "," << std::endl; + os << "\t\t\t}," << std::endl; + os << "\t\t\t{" << std::endl; + os << "\t\t\t\t\"domain\": [" << instance.d2.domain.lower_bound << ", " + << instance.d2.domain.upper_bound << "]," << std::endl; + os << "\t\t\t\t\"extent\": " << instance.d2.extent << "," << std::endl; + os << "\t\t\t}" << std::endl; + os << "\t\t]" << std::endl; + + os << "\t}," << std::endl; + os << "\t\"memory\": {" << std::endl; + os << "\t\t\"total_budget\": " << instance.memory.total_budget_ << ", " + << std::endl; + os << "\t\t\"ratio_tile_ranges\": " << instance.memory.ratio_tile_ranges_ + << ", " << std::endl; + os << "\t\t\"ratio_array_data\": " << instance.memory.ratio_array_data_ + << ", " << std::endl; + os << "\t\t\"ratio_coords\": " << instance.memory.ratio_coords_ << std::endl; + os << "\t}" << std::endl; + os << "}"; +} + } // namespace rc TEST_CASE_METHOD( From 0c92556f0f1053f07964423176d622ea2ac8239d Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 30 Dec 2024 10:42:16 -0500 Subject: [PATCH 086/228] Fix CSparseGlobalOrderFx::run to sort 'expect' in global order --- test/src/unit-sparse-global-order-reader.cc | 19 ++++++----- test/support/rapidcheck/array.h | 35 +++++++++++++++++++++ 2 files changed, 46 insertions(+), 8 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index b6e1f3fa028..c715ebba216 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2611,18 +2611,24 @@ void CSparseGlobalOrderFx::run(Instance instance) { } } + // Open array for reading. + CApiArray array(ctx_, array_name_.c_str(), TILEDB_READ); + // sort for naive comparison { std::vector idxs(expect.size()); std::iota(idxs.begin(), idxs.end(), 0); + sm::GlobalCellCmp globalcmp(array->array()->array_schema_latest().domain()); + std::sort(idxs.begin(), idxs.end(), [&](uint64_t ia, uint64_t ib) -> bool { return std::apply( - [ia, ib](const std::vector&... dims) { - const auto l = {dims[ia]...}; - const auto r = {dims[ib]...}; - return std::lexicographical_compare( - l.begin(), l.end(), r.begin(), r.end()); + [&globalcmp, ia, ib](const std::vector&... dims) { + const auto l = std::make_tuple(dims[ia]...); + const auto r = std::make_tuple(dims[ib]...); + return globalcmp( + tdbrc::global_cell_cmp_std_tuple(l), + tdbrc::global_cell_cmp_std_tuple(r)); }, expect.dimensions()); }); @@ -2633,9 +2639,6 @@ void CSparseGlobalOrderFx::run(Instance instance) { stdx::reference_tuple(expect.attributes()), std::span(idxs)); } - // Open array for reading. - CApiArray array(ctx_, array_name_.c_str(), TILEDB_READ); - // Create query tiledb_query_t* query; auto rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); diff --git a/test/support/rapidcheck/array.h b/test/support/rapidcheck/array.h index bc91fa8792f..e3835d63c38 100644 --- a/test/support/rapidcheck/array.h +++ b/test/support/rapidcheck/array.h @@ -45,8 +45,43 @@ #include #include +namespace tiledb::sm { +class Dimension; +} + namespace tiledb::test::tdbrc { +template +struct global_cell_cmp_std_tuple { + global_cell_cmp_std_tuple(const StdTuple& tup) + : tup_(tup) { + } + + tiledb::common::UntypedDatumView dimension_datum( + const tiledb::sm::Dimension&, unsigned dim_idx) const { + return std::apply( + [&](const auto&... field) { + size_t sizes[] = {sizeof(std::decay_t)...}; + const void* const ptrs[] = { + static_cast(std::addressof(field))...}; + return UntypedDatumView(ptrs[dim_idx], sizes[dim_idx]); + }, + tup_); + } + + const void* coord(unsigned dim) const { + return std::apply( + [&](const auto&... field) { + const void* const ptrs[] = { + static_cast(std::addressof(field))...}; + return ptrs[dim]; + }, + tup_); + } + + const StdTuple& tup_; +}; + /** * Describes types which can be used for rapidcheck-generated dimensions. */ From 010f83b7859103c7865da3db87dde7de25d6d765 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 31 Dec 2024 09:22:16 -0500 Subject: [PATCH 087/228] vfs_test_get_fs_vec requires S3 to add rest-s3 --- test/support/src/vfs_helpers.cc | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/test/support/src/vfs_helpers.cc b/test/support/src/vfs_helpers.cc index e488ac5833e..7935f1d4253 100644 --- a/test/support/src/vfs_helpers.cc +++ b/test/support/src/vfs_helpers.cc @@ -84,7 +84,11 @@ std::vector> vfs_test_get_fs_vec() { } if (supports_rest_s3) { - fs_vec.emplace_back(std::make_unique(true)); + if (tiledb::sm::filesystem::s3_enabled) { + fs_vec.emplace_back(std::make_unique(true)); + } else { + throw tiledb::sm::filesystem::BuiltWithout("S3"); + } } fs_vec.emplace_back(std::make_unique()); From c793f476cd6c24e7fc7a0a5f477a2649b3b975da Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 31 Dec 2024 10:51:24 -0500 Subject: [PATCH 088/228] Use VFS in CSparseGlobalOrderFx and add error detail to helpers.cc REQUIRE --- test/src/unit-sparse-global-order-reader.cc | 81 ++--- test/support/src/error_helpers.h | 94 ++++++ test/support/src/helpers.cc | 338 ++++++++++---------- 3 files changed, 281 insertions(+), 232 deletions(-) create mode 100644 test/support/src/error_helpers.h diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index c715ebba216..ed93c9ebfa2 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -31,6 +31,7 @@ */ #include "test/support/rapidcheck/array.h" +#include "test/support/src/error_helpers.h" #include "test/support/src/helpers.h" #include "test/support/src/vfs_helpers.h" #include "tiledb/api/c_api/array/array_api_internal.h" @@ -69,14 +70,6 @@ Gen>> make_subarray_1d( const tdbrc::Domain& domain); } -#define RETURN_IF_ERR(thing) \ - do { \ - auto rc = (thing); \ - if (rc != TILEDB_OK) { \ - return rc; \ - } \ - } while (0) - /* ********************************* */ /* STRUCT DEFINITION */ /* ********************************* */ @@ -447,9 +440,9 @@ concept InstanceType = requires(const T& instance) { }; struct CSparseGlobalOrderFx { + VFSTestSetup vfs_test_setup_; + tiledb_ctx_t* ctx_ = nullptr; - tiledb_vfs_t* vfs_ = nullptr; - std::string temp_dir_; std::string array_name_; const char* ARRAY_NAME = "test_sparse_global_order"; tiledb_array_t* array_ = nullptr; @@ -519,58 +512,22 @@ struct CSparseGlobalOrderFx { ~CSparseGlobalOrderFx(); }; -#define TRY(thing) \ - do { \ - auto rc = (thing); \ - RCCATCH_REQUIRE("" == error_if_any(rc)); \ - } while (0) - -template -std::string error_if_any(tiledb_ctx_t* ctx, CAPIReturn apirc) { - if (apirc == TILEDB_OK) { - return ""; - } - - tiledb_error_t* error = NULL; - auto rc = tiledb_ctx_get_last_error(ctx, &error); - REQUIRE(rc == TILEDB_OK); - if (error == nullptr) { - // probably should be unreachable - return ""; - } - - const char* msg; - rc = tiledb_error_message(error, &msg); - REQUIRE(rc == TILEDB_OK); - - return std::string(msg); -} - template std::string CSparseGlobalOrderFx::error_if_any(CAPIReturn apirc) const { - return ::error_if_any(ctx_, apirc); + return tiledb::test::error_if_any(ctx_, apirc); } CSparseGlobalOrderFx::CSparseGlobalOrderFx() { reset_config(); - // Create temporary directory based on the supported filesystem. -#ifdef _WIN32 - temp_dir_ = tiledb::sm::Win::current_dir() + "\\tiledb_test\\"; -#else - temp_dir_ = "file://" + tiledb::sm::Posix::current_dir() + "/tiledb_test/"; -#endif - create_dir(temp_dir_, ctx_, vfs_); - array_name_ = temp_dir_ + ARRAY_NAME; + array_name_ = vfs_test_setup_.array_uri("tiledb_test"); } CSparseGlobalOrderFx::~CSparseGlobalOrderFx() { if (array_) { tiledb_array_free(&array_); } - remove_dir(temp_dir_, ctx_, vfs_); tiledb_ctx_free(&ctx_); - tiledb_vfs_free(&vfs_); } void CSparseGlobalOrderFx::reset_config() { @@ -582,9 +539,6 @@ void CSparseGlobalOrderFx::update_config() { if (ctx_ != nullptr) tiledb_ctx_free(&ctx_); - if (vfs_ != nullptr) - tiledb_vfs_free(&vfs_); - tiledb_config_t* config; tiledb_error_t* error = nullptr; REQUIRE(tiledb_config_alloc(&config, &error) == TILEDB_OK); @@ -632,7 +586,6 @@ void CSparseGlobalOrderFx::update_config() { REQUIRE(tiledb_ctx_alloc(config, &ctx_) == TILEDB_OK); REQUIRE(error == nullptr); - REQUIRE(tiledb_vfs_alloc(ctx_, config, &vfs_) == TILEDB_OK); tiledb_config_free(&config); } @@ -2087,12 +2040,13 @@ TEST_CASE_METHOD( CHECK(!std::memcmp(data_c, data_r, data_r_size)); } -TEST_CASE( +TEST_CASE_METHOD( + CSparseGlobalOrderFx, "Sparse global order reader: user buffer cannot fit single cell", "[sparse-global-order][user-buffer][too-small][rest]") { - VFSTestSetup vfs_test_setup; - std::string array_name = vfs_test_setup.array_uri("test_sparse_global_order"); - auto ctx = vfs_test_setup.ctx(); + std::string array_name = + vfs_test_setup_.array_uri("test_sparse_global_order"); + auto ctx = vfs_test_setup_.ctx(); // Create array with var-sized attribute. Domain dom(ctx); @@ -2157,14 +2111,15 @@ TEST_CASE( array2.close(); } -TEST_CASE( +TEST_CASE_METHOD( + CSparseGlobalOrderFx, "Sparse global order reader: attribute copy memory limit", "[sparse-global-order][attribute-copy][memory-limit][rest]") { Config config; config["sm.mem.total_budget"] = "20000"; - VFSTestSetup vfs_test_setup(config.ptr().get()); - std::string array_name = vfs_test_setup.array_uri("test_sparse_global_order"); - auto ctx = vfs_test_setup.ctx(); + std::string array_name = + vfs_test_setup_.array_uri("test_sparse_global_order"); + auto ctx = vfs_test_setup_.ctx(); // Create array with var-sized attribute. Domain dom(ctx); @@ -2648,9 +2603,9 @@ void CSparseGlobalOrderFx::run(Instance instance) { if (!instance.subarray.empty()) { tiledb_subarray_t* subarray; - TRY(tiledb_subarray_alloc(ctx_, array, &subarray)); - TRY(instance.template apply_subarray(ctx_, subarray)); - TRY(tiledb_query_set_subarray_t(ctx_, query, subarray)); + TRY(ctx_, tiledb_subarray_alloc(ctx_, array, &subarray)); + TRY(ctx_, instance.template apply_subarray(ctx_, subarray)); + TRY(ctx_, tiledb_query_set_subarray_t(ctx_, query, subarray)); tiledb_subarray_free(&subarray); } diff --git a/test/support/src/error_helpers.h b/test/support/src/error_helpers.h new file mode 100644 index 00000000000..816079b4c0e --- /dev/null +++ b/test/support/src/error_helpers.h @@ -0,0 +1,94 @@ +/** + * @file error_helpers.h + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2017-2024 TileDB, 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. + * + * @section DESCRIPTION + * + * This file declares helper functions, macros, etc for reporting errors. + */ + +#ifndef TILEDB_TEST_ERROR_HELPERS_H +#define TILEDB_TEST_ERROR_HELPERS_H + +#include "tiledb.h" + +/** + * Calls a C API function and returns its status if it is not TILEDB_OK. + */ +#define RETURN_IF_ERR(thing) \ + do { \ + auto rc = (thing); \ + if (rc != TILEDB_OK) { \ + return rc; \ + } \ + } while (0) + +/** + * Asserts that a C API call does not return error. + */ +#define TRY(ctx, thing) \ + do { \ + auto rc = (thing); \ + RCCATCH_REQUIRE("" == tiledb::test::error_if_any(ctx, rc)); \ + } while (0) + +namespace tiledb::test { + +/** + * Helper function for not just reporting the return code of a C API call + * but also the error message. + * + * Usage: + * ``` + * auto rc = c_api_invocation(); + * REQUIRE("" == error_if_any(rc)); + * ``` + */ +template +std::string error_if_any(tiledb_ctx_t* ctx, CAPIReturn apirc) { + if (apirc == TILEDB_OK) { + return ""; + } + + tiledb_error_t* error = NULL; + auto rc = tiledb_ctx_get_last_error(ctx, &error); + REQUIRE(rc == TILEDB_OK); + if (error == nullptr) { + // probably should be unreachable + return ""; + } + + const char* msg; + rc = tiledb_error_message(error, &msg); + REQUIRE(rc == TILEDB_OK); + + return std::string(msg); +} + +} // namespace tiledb::test + +#endif + diff --git a/test/support/src/helpers.cc b/test/support/src/helpers.cc index 3b6cce07384..cb3c1836e02 100644 --- a/test/support/src/helpers.cc +++ b/test/support/src/helpers.cc @@ -39,6 +39,7 @@ #endif #include +#include "error_helpers.h" #include "helpers.h" #include "serialization_wrappers.h" #include "tiledb/api/c_api/array/array_api_internal.h" @@ -194,7 +195,7 @@ bool use_refactored_dense_reader() { REQUIRE(err == nullptr); rc = tiledb_config_get(cfg, "sm.query.dense.reader", &value, &err); - CHECK(rc == TILEDB_OK); + REQUIRE(rc == TILEDB_OK); CHECK(err == nullptr); bool use_refactored_readers = strcmp(value, "refactored") == 0; @@ -214,7 +215,7 @@ bool use_refactored_sparse_global_order_reader() { rc = tiledb_config_get( cfg, "sm.query.sparse_global_order.reader", &value, &err); - CHECK(rc == TILEDB_OK); + REQUIRE(rc == TILEDB_OK); CHECK(err == nullptr); bool use_refactored_readers = strcmp(value, "refactored") == 0; @@ -234,7 +235,7 @@ bool use_refactored_sparse_unordered_with_dups_reader() { rc = tiledb_config_get( cfg, "sm.query.sparse_unordered_with_dups.reader", &value, &err); - CHECK(rc == TILEDB_OK); + REQUIRE(rc == TILEDB_OK); CHECK(err == nullptr); bool use_refactored_readers = strcmp(value, "refactored") == 0; @@ -461,70 +462,72 @@ void create_array( // Create array schema tiledb_array_schema_t* array_schema; - int rc = tiledb_array_schema_alloc(ctx, array_type, &array_schema); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_set_cell_order(ctx, array_schema, cell_order); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_set_tile_order(ctx, array_schema, tile_order); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_set_capacity(ctx, array_schema, capacity); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_set_allows_dups(ctx, array_schema, (int)allows_dups); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, tiledb_array_schema_alloc(ctx, array_type, &array_schema)); + require_tiledb_ok( + ctx, tiledb_array_schema_set_cell_order(ctx, array_schema, cell_order)); + require_tiledb_ok( + ctx, tiledb_array_schema_set_tile_order(ctx, array_schema, tile_order)); + require_tiledb_ok( + ctx, tiledb_array_schema_set_capacity(ctx, array_schema, capacity)); + require_tiledb_ok( + ctx, + tiledb_array_schema_set_allows_dups(ctx, array_schema, (int)allows_dups)); // Create dimensions and domain tiledb_domain_t* domain; - rc = tiledb_domain_alloc(ctx, &domain); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok(ctx, tiledb_domain_alloc(ctx, &domain)); for (size_t i = 0; i < dim_num; ++i) { tiledb_dimension_t* d; - rc = tiledb_dimension_alloc( + require_tiledb_ok( ctx, - dim_names[i].c_str(), - dim_types[i], - dim_domains[i], - tile_extents[i], - &d); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_domain_add_dimension(ctx, domain, d); - REQUIRE(rc == TILEDB_OK); + tiledb_dimension_alloc( + ctx, + dim_names[i].c_str(), + dim_types[i], + dim_domains[i], + tile_extents[i], + &d)); + require_tiledb_ok(ctx, tiledb_domain_add_dimension(ctx, domain, d)); tiledb_dimension_free(&d); } // Set domain to schema - rc = tiledb_array_schema_set_domain(ctx, array_schema, domain); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, tiledb_array_schema_set_domain(ctx, array_schema, domain)); tiledb_domain_free(&domain); // Create attributes for (size_t i = 0; i < attr_num; ++i) { tiledb_attribute_t* a; - rc = tiledb_attribute_alloc(ctx, attr_names[i].c_str(), attr_types[i], &a); - REQUIRE(rc == TILEDB_OK); - rc = set_attribute_compression_filter( - ctx, a, compressors[i].first, compressors[i].second); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_attribute_set_cell_val_num(ctx, a, cell_val_num[i]); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, + tiledb_attribute_alloc(ctx, attr_names[i].c_str(), attr_types[i], &a)); + require_tiledb_ok( + ctx, + set_attribute_compression_filter( + ctx, a, compressors[i].first, compressors[i].second)); + require_tiledb_ok( + ctx, tiledb_attribute_set_cell_val_num(ctx, a, cell_val_num[i])); if (nullable != nullopt) { - rc = tiledb_attribute_set_nullable(ctx, a, nullable.value()[i]); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, tiledb_attribute_set_nullable(ctx, a, nullable.value()[i])); } - rc = tiledb_array_schema_add_attribute(ctx, array_schema, a); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, tiledb_array_schema_add_attribute(ctx, array_schema, a)); tiledb_attribute_free(&a); } // Check array schema - rc = tiledb_array_schema_check(ctx, array_schema); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok(ctx, tiledb_array_schema_check(ctx, array_schema)); // Create array - rc = tiledb_array_create_serialization_wrapper( - ctx, array_name, array_schema, serialize_array_schema); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, + tiledb_array_create_serialization_wrapper( + ctx, array_name, array_schema, serialize_array_schema)); // Clean up tiledb_array_schema_free(&array_schema); @@ -561,76 +564,80 @@ void create_array( // Create array schema tiledb_array_schema_t* array_schema; - int rc = tiledb_array_schema_alloc(ctx, array_type, &array_schema); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_set_cell_order(ctx, array_schema, cell_order); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_set_tile_order(ctx, array_schema, tile_order); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_set_capacity(ctx, array_schema, capacity); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, tiledb_array_schema_alloc(ctx, array_type, &array_schema)); + require_tiledb_ok( + ctx, tiledb_array_schema_set_cell_order(ctx, array_schema, cell_order)); + require_tiledb_ok( + ctx, tiledb_array_schema_set_tile_order(ctx, array_schema, tile_order)); + require_tiledb_ok( + ctx, tiledb_array_schema_set_capacity(ctx, array_schema, capacity)); // Create dimensions and domain tiledb_domain_t* domain; - rc = tiledb_domain_alloc(ctx, &domain); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok(ctx, tiledb_domain_alloc(ctx, &domain)); for (size_t i = 0; i < dim_num; ++i) { tiledb_dimension_t* d; - rc = tiledb_dimension_alloc( + require_tiledb_ok( ctx, - dim_names[i].c_str(), - dim_types[i], - dim_domains[i], - tile_extents[i], - &d); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_domain_add_dimension(ctx, domain, d); - REQUIRE(rc == TILEDB_OK); + tiledb_dimension_alloc( + ctx, + dim_names[i].c_str(), + dim_types[i], + dim_domains[i], + tile_extents[i], + &d)); + require_tiledb_ok(ctx, tiledb_domain_add_dimension(ctx, domain, d)); tiledb_dimension_free(&d); } // Set domain to schema - rc = tiledb_array_schema_set_domain(ctx, array_schema, domain); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, tiledb_array_schema_set_domain(ctx, array_schema, domain)); tiledb_domain_free(&domain); // Create attributes for (size_t i = 0; i < attr_num; ++i) { tiledb_attribute_t* a; - rc = tiledb_attribute_alloc(ctx, attr_names[i].c_str(), attr_types[i], &a); - REQUIRE(rc == TILEDB_OK); - rc = set_attribute_compression_filter( - ctx, a, compressors[i].first, compressors[i].second); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_attribute_set_cell_val_num(ctx, a, cell_val_num[i]); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_add_attribute(ctx, array_schema, a); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, + tiledb_attribute_alloc(ctx, attr_names[i].c_str(), attr_types[i], &a)); + require_tiledb_ok( + ctx, + set_attribute_compression_filter( + ctx, a, compressors[i].first, compressors[i].second)); + require_tiledb_ok( + ctx, tiledb_attribute_set_cell_val_num(ctx, a, cell_val_num[i])); + require_tiledb_ok( + ctx, tiledb_array_schema_add_attribute(ctx, array_schema, a)); tiledb_attribute_free(&a); } // Check array schema - rc = tiledb_array_schema_check(ctx, array_schema); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok(ctx, tiledb_array_schema_check(ctx, array_schema)); // Create array tiledb_config_t* config; tiledb_error_t* error = nullptr; - rc = tiledb_config_alloc(&config, &error); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok(ctx, tiledb_config_alloc(&config, &error)); REQUIRE(error == nullptr); std::string encryption_type_string = encryption_type_str((tiledb::sm::EncryptionType)enc_type); - rc = tiledb_config_set( - config, "sm.encryption_type", encryption_type_string.c_str(), &error); + require_tiledb_ok( + ctx, + tiledb_config_set( + config, + "sm.encryption_type", + encryption_type_string.c_str(), + &error)); REQUIRE(error == nullptr); - rc = tiledb_config_set(config, "sm.encryption_key", key, &error); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, tiledb_config_set(config, "sm.encryption_key", key, &error)); REQUIRE(error == nullptr); tiledb_ctx_t* ctx_array; REQUIRE(tiledb_ctx_alloc(config, &ctx_array) == TILEDB_OK); - rc = tiledb_array_create(ctx_array, array_name.c_str(), array_schema); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, tiledb_array_create(ctx_array, array_name.c_str(), array_schema)); // Clean up tiledb_array_schema_free(&array_schema); @@ -666,59 +673,60 @@ tiledb_array_schema_t* create_array_schema( // Create array schema tiledb_array_schema_t* array_schema; - int rc = tiledb_array_schema_alloc(ctx, array_type, &array_schema); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_set_cell_order(ctx, array_schema, cell_order); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_set_tile_order(ctx, array_schema, tile_order); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_set_capacity(ctx, array_schema, capacity); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_set_allows_dups(ctx, array_schema, (int)allows_dups); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, tiledb_array_schema_alloc(ctx, array_type, &array_schema)); + require_tiledb_ok( + ctx, tiledb_array_schema_set_cell_order(ctx, array_schema, cell_order)); + require_tiledb_ok( + ctx, tiledb_array_schema_set_tile_order(ctx, array_schema, tile_order)); + require_tiledb_ok( + ctx, tiledb_array_schema_set_capacity(ctx, array_schema, capacity)); + require_tiledb_ok( + ctx, + tiledb_array_schema_set_allows_dups(ctx, array_schema, (int)allows_dups)); // Create dimensions and domain tiledb_domain_t* domain; - rc = tiledb_domain_alloc(ctx, &domain); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok(ctx, tiledb_domain_alloc(ctx, &domain)); for (size_t i = 0; i < dim_num; ++i) { tiledb_dimension_t* d; - rc = tiledb_dimension_alloc( + require_tiledb_ok( ctx, - dim_names[i].c_str(), - dim_types[i], - dim_domains[i], - tile_extents[i], - &d); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_domain_add_dimension(ctx, domain, d); - REQUIRE(rc == TILEDB_OK); + tiledb_dimension_alloc( + ctx, + dim_names[i].c_str(), + dim_types[i], + dim_domains[i], + tile_extents[i], + &d)); + require_tiledb_ok(ctx, tiledb_domain_add_dimension(ctx, domain, d)); tiledb_dimension_free(&d); } // Set domain to schema - rc = tiledb_array_schema_set_domain(ctx, array_schema, domain); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, tiledb_array_schema_set_domain(ctx, array_schema, domain)); tiledb_domain_free(&domain); // Create attributes for (size_t i = 0; i < attr_num; ++i) { tiledb_attribute_t* a; - rc = tiledb_attribute_alloc(ctx, attr_names[i].c_str(), attr_types[i], &a); - REQUIRE(rc == TILEDB_OK); - rc = set_attribute_compression_filter( - ctx, a, compressors[i].first, compressors[i].second); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_attribute_set_cell_val_num(ctx, a, cell_val_num[i]); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_add_attribute(ctx, array_schema, a); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, + tiledb_attribute_alloc(ctx, attr_names[i].c_str(), attr_types[i], &a)); + require_tiledb_ok( + ctx, + set_attribute_compression_filter( + ctx, a, compressors[i].first, compressors[i].second)); + require_tiledb_ok( + ctx, tiledb_attribute_set_cell_val_num(ctx, a, cell_val_num[i])); + require_tiledb_ok( + ctx, tiledb_array_schema_add_attribute(ctx, array_schema, a)); tiledb_attribute_free(&a); } // Check array schema - rc = tiledb_array_schema_check(ctx, array_schema); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok(ctx, tiledb_array_schema_check(ctx, array_schema)); // Clean up return array_schema; @@ -732,11 +740,11 @@ void create_s3_bucket( if (s3_supported) { // Create bucket if it does not exist int is_bucket = 0; - int rc = tiledb_vfs_is_bucket(ctx, vfs, bucket_name.c_str(), &is_bucket); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, tiledb_vfs_is_bucket(ctx, vfs, bucket_name.c_str(), &is_bucket)); if (!is_bucket) { - rc = tiledb_vfs_create_bucket(ctx, vfs, bucket_name.c_str()); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, tiledb_vfs_create_bucket(ctx, vfs, bucket_name.c_str())); } } } @@ -749,12 +757,12 @@ void create_azure_container( if (azure_supported) { // Create container if it does not exist int is_container = 0; - int rc = - tiledb_vfs_is_bucket(ctx, vfs, container_name.c_str(), &is_container); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, + tiledb_vfs_is_bucket(ctx, vfs, container_name.c_str(), &is_container)); if (!is_container) { - rc = tiledb_vfs_create_bucket(ctx, vfs, container_name.c_str()); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, tiledb_vfs_create_bucket(ctx, vfs, container_name.c_str())); } } } @@ -823,22 +831,21 @@ void create_subarray( tiledb_subarray_t** subarray, bool coalesce_ranges) { (void)layout; - int32_t rc; tiledb_array_t tdb_array = *tiledb_array_t::make_handle(array); - rc = tiledb_subarray_alloc(ctx, &tdb_array, subarray); - REQUIRE(rc == TILEDB_OK); - if (rc == TILEDB_OK) { - rc = tiledb_subarray_set_coalesce_ranges(ctx, *subarray, coalesce_ranges); - REQUIRE(rc == TILEDB_OK); - - auto dim_num = (unsigned)ranges.size(); - for (unsigned d = 0; d < dim_num; ++d) { - auto dim_range_num = ranges[d].size() / 2; - for (size_t j = 0; j < dim_range_num; ++j) { - rc = tiledb_subarray_add_range( - ctx, *subarray, d, &ranges[d][2 * j], &ranges[d][2 * j + 1], 0); - REQUIRE(rc == TILEDB_OK); - } + require_tiledb_ok(ctx, tiledb_subarray_alloc(ctx, &tdb_array, subarray)); + + require_tiledb_ok( + ctx, + tiledb_subarray_set_coalesce_ranges(ctx, *subarray, coalesce_ranges)); + + auto dim_num = (unsigned)ranges.size(); + for (unsigned d = 0; d < dim_num; ++d) { + auto dim_range_num = ranges[d].size() / 2; + for (size_t j = 0; j < dim_range_num; ++j) { + require_tiledb_ok( + ctx, + tiledb_subarray_add_range( + ctx, *subarray, d, &ranges[d][2 * j], &ranges[d][2 * j + 1], 0)); } } } @@ -906,17 +913,14 @@ int set_attribute_compression_filter( return TILEDB_OK; tiledb_filter_t* filter; - int rc = tiledb_filter_alloc(ctx, compressor, &filter); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_filter_set_option(ctx, filter, TILEDB_COMPRESSION_LEVEL, &level); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok(ctx, tiledb_filter_alloc(ctx, compressor, &filter)); + require_tiledb_ok( + ctx, + tiledb_filter_set_option(ctx, filter, TILEDB_COMPRESSION_LEVEL, &level)); tiledb_filter_list_t* list; - rc = tiledb_filter_list_alloc(ctx, &list); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_filter_list_add_filter(ctx, list, filter); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_attribute_set_filter_list(ctx, attr, list); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok(ctx, tiledb_filter_list_alloc(ctx, &list)); + require_tiledb_ok(ctx, tiledb_filter_list_add_filter(ctx, list, filter)); + require_tiledb_ok(ctx, tiledb_attribute_set_filter_list(ctx, attr, list)); tiledb_filter_free(&filter); tiledb_filter_list_free(&list); @@ -1076,22 +1080,22 @@ void write_array( REQUIRE(tiledb_config_alloc(&cfg, &err) == TILEDB_OK); REQUIRE(err == nullptr); - rc = tiledb_array_set_open_timestamp_end(ctx, array, timestamp); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, tiledb_array_set_open_timestamp_end(ctx, array, timestamp)); // Open array if (encryption_type != TILEDB_NO_ENCRYPTION) { std::string encryption_type_string = encryption_type_str((tiledb::sm::EncryptionType)encryption_type); - rc = tiledb_config_set( - cfg, "sm.encryption_type", encryption_type_string.c_str(), &err); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, + tiledb_config_set( + cfg, "sm.encryption_type", encryption_type_string.c_str(), &err)); REQUIRE(err == nullptr); - rc = tiledb_config_set(cfg, "sm.encryption_key", key, &err); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, tiledb_config_set(cfg, "sm.encryption_key", key, &err)); REQUIRE(err == nullptr); - rc = tiledb_array_set_config(ctx, array, cfg); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok(ctx, tiledb_array_set_config(ctx, array, cfg)); } rc = tiledb_array_open(ctx, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); @@ -1102,12 +1106,9 @@ void write_array( CHECK(rc == TILEDB_OK); tiledb_subarray_t* subarray; if (sub != nullptr) { - rc = tiledb_subarray_alloc(ctx, array, &subarray); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_subarray_set_subarray(ctx, subarray, sub); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_set_subarray_t(ctx, query, subarray); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok(ctx, tiledb_subarray_alloc(ctx, array, &subarray)); + require_tiledb_ok(ctx, tiledb_subarray_set_subarray(ctx, subarray, sub)); + require_tiledb_ok(ctx, tiledb_query_set_subarray_t(ctx, query, subarray)); } rc = tiledb_query_set_layout(ctx, query, layout); CHECK(rc == TILEDB_OK); @@ -1150,13 +1151,12 @@ void write_array( // Get fragment uri const char* temp_uri; - rc = tiledb_query_get_fragment_uri(ctx, query, 0, &temp_uri); - REQUIRE(rc == TILEDB_OK); + require_tiledb_ok( + ctx, tiledb_query_get_fragment_uri(ctx, query, 0, &temp_uri)); *uri = std::string(temp_uri); // Close array - rc = tiledb_array_close(ctx, array); - CHECK(rc == TILEDB_OK); + require_tiledb_ok(ctx, tiledb_array_close(ctx, array)); // Clean up tiledb_array_free(&array); From 29441ec160b8cff59306626656f9aab8e2331f16 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 31 Dec 2024 11:25:03 -0500 Subject: [PATCH 089/228] Update unit test for REST --- test/src/unit-sparse-global-order-reader.cc | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index ed93c9ebfa2..4b7defa996c 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2648,8 +2648,11 @@ void CSparseGlobalOrderFx::run(Instance instance) { const auto err = error_if_any(rc); if (err.find("Cannot load enough tiles to emit results from all " "fragments in global order") != std::string::npos) { - RCCATCH_REQUIRE(!can_complete_in_memory_budget( - ctx_, array_name_.c_str(), instance)); + if (!vfs_test_setup_.is_rest()) { + // skip for REST since we will not have access to tile sizes + RCCATCH_REQUIRE(!can_complete_in_memory_budget( + ctx_, array_name_.c_str(), instance)); + } tiledb_query_free(&query); return; } else if (err.find("Cannot load tile offsets") != std::string::npos) { @@ -2684,6 +2687,7 @@ void CSparseGlobalOrderFx::run(Instance instance) { } outcursor += dim_num_cells; + REQUIRE(outcursor <= expect.size()); if (status == TILEDB_COMPLETED) { break; @@ -2734,8 +2738,11 @@ void CSparseGlobalOrderFx::run(Instance instance) { } // lastly, check the correctness of our memory budgeting function - RCCATCH_REQUIRE( - can_complete_in_memory_budget(ctx_, array_name_.c_str(), instance)); + // (skip for REST since we will not have access to tile sizes) + if (!vfs_test_setup_.is_rest()) { + RCCATCH_REQUIRE( + can_complete_in_memory_budget(ctx_, array_name_.c_str(), instance)); + } } namespace rc { From e44c70706121e72b8cc21984b2277321eadb9867 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 31 Dec 2024 13:13:59 -0500 Subject: [PATCH 090/228] Serialization of preprocess works --- test/src/unit-sparse-global-order-reader.cc | 6 +- .../readers/sparse_global_order_reader.cc | 12 +- .../readers/sparse_global_order_reader.h | 17 +- .../query/readers/sparse_index_reader_base.cc | 14 + .../query/readers/sparse_index_reader_base.h | 33 + tiledb/sm/serialization/query.cc | 11 + tiledb/sm/serialization/tiledb-rest.capnp | 6 + tiledb/sm/serialization/tiledb-rest.capnp.c++ | 120 +- tiledb/sm/serialization/tiledb-rest.capnp.h | 34420 ++++++---------- 9 files changed, 12818 insertions(+), 21821 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 4b7defa996c..6c92eb387e1 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -1385,7 +1385,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: fragment skew", - "[sparse-global-order]") { + "[sparse-global-order][rest]") { auto doit = [this]( size_t fragment_size, size_t num_user_cells, @@ -1459,7 +1459,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: fragment interleave", - "[sparse-global-order]") { + "[sparse-global-order][rest]") { // NB: the tile extent is 2 auto doit = [this]( size_t fragment_size, @@ -1553,7 +1553,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: fragment wide overlap", - "[sparse-global-order]") { + "[sparse-global-order][rest]") { auto doit = [this]( size_t num_fragments, size_t fragment_size, diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 264b5c7f853..e4e75fe476d 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -162,6 +162,16 @@ void SparseGlobalOrderReader::refresh_config() { memory_budget_.refresh_config(config_, "sparse_global_order"); } +template +void SparseGlobalOrderReader::set_preprocess_tile_order_cursor( + uint64_t cursor) { + preprocess_tile_order_.enabled_ = true; + preprocess_tile_order_.cursor_ = cursor; + + // The tile order itself will be recomputed. + // We get smaller messages but at a higher CPU cost. +} + template Status SparseGlobalOrderReader::dowork() { auto timer_se = stats_->start_timer("dowork"); @@ -590,8 +600,6 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( default: stdx::unreachable(); } - - preprocess_tile_order_.cursor_ = 0; } template diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index 4623b2ad1a2..dbf4895cf0d 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -135,6 +135,9 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, /** Returns the name of the strategy */ std::string name(); + /** Used in deserialization */ + virtual void set_preprocess_tile_order_cursor(uint64_t cursor) override; + private: /* ********************************* */ /* PRIVATE ATTRIBUTES */ @@ -149,20 +152,6 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, */ std::vector result_tiles_leftover_; - /** - * State for the optional mode to preprocess the tile MBRs - * and merge them into a single globally-ordered list prior - * to loading any tiles. - * - * Tile identifiers in this list are sorted using their starting ranges - * and have already had the subarray (if any) applied. - */ - struct { - bool enabled_; - std::vector tiles_; - size_t cursor_; - } preprocess_tile_order_; - /** * State for the default mode to evenly distribute memory * budget amongst the fragments and create a result diff --git a/tiledb/sm/query/readers/sparse_index_reader_base.cc b/tiledb/sm/query/readers/sparse_index_reader_base.cc index 1956529a140..40fed5a0184 100644 --- a/tiledb/sm/query/readers/sparse_index_reader_base.cc +++ b/tiledb/sm/query/readers/sparse_index_reader_base.cc @@ -83,6 +83,10 @@ SparseIndexReaderBase::SparseIndexReaderBase( "Cannot initialize reader; Buffers not set"); } + // Clear preprocess tile order + preprocess_tile_order_.enabled_ = false; + preprocess_tile_order_.cursor_ = 0; + // Check subarray check_subarray(); @@ -133,6 +137,16 @@ void SparseIndexReaderBase::set_read_state(ReadState read_state) { read_state_ = std::move(read_state); } +const PreprocessTileOrder SparseIndexReaderBase::preprocess_tile_order() const { + return preprocess_tile_order_; +} + +void SparseIndexReaderBase::set_preprocess_tile_order_cursor(uint64_t) { + throw SparseIndexReaderBaseException( + "Internal error: set_preprocess_tile_order_cursor for unsupported sparse " + "index reader"); +} + uint64_t SparseIndexReaderBase::available_memory() { return memory_budget_.total_budget() - memory_used_for_coords_total_ - tmp_read_state_.memory_used_tile_ranges() - diff --git a/tiledb/sm/query/readers/sparse_index_reader_base.h b/tiledb/sm/query/readers/sparse_index_reader_base.h index 2a7553a70ed..f037f46db48 100644 --- a/tiledb/sm/query/readers/sparse_index_reader_base.h +++ b/tiledb/sm/query/readers/sparse_index_reader_base.h @@ -294,6 +294,16 @@ struct ignored_tile_hash { } }; +/** + * Identifies an order in which to load result tiles. + * See `SparseIndexReader::preprocess_tile_order_`. + */ +struct PreprocessTileOrder { + bool enabled_; + size_t cursor_; + std::vector tiles_; +}; + /** * Processes sparse read queries by keeping progress in fragments as indexes. */ @@ -601,11 +611,34 @@ class SparseIndexReaderBase : public ReaderBase { */ void set_read_state(ReadState read_state); + const PreprocessTileOrder preprocess_tile_order() const; + + /** + * Sets the preprocess tile order cursor. Used only for deserialization + * + * @param cursor New cursor value. + */ + virtual void set_preprocess_tile_order_cursor(uint64_t cursor); + protected: /* ********************************* */ /* PROTECTED ATTRIBUTES */ /* ********************************* */ + /** + * State for the optional mode to preprocess the tiles across + * all fragments and merge them into a single list which identifies + * the order they should be read in. + * + * This is used by SparseGlobalOrderReader to merge the tiles + * into a single globally-ordered list prior to loading. + * Tile identifiers in this list are sorted using their starting ranges + * and have already had the subarray (if any) applied. + * + * (this is declared here for serialization purposes) + */ + PreprocessTileOrder preprocess_tile_order_; + /** Read state. */ ReadState read_state_; diff --git a/tiledb/sm/serialization/query.cc b/tiledb/sm/serialization/query.cc index b6590c7e387..6f37120d901 100644 --- a/tiledb/sm/serialization/query.cc +++ b/tiledb/sm/serialization/query.cc @@ -933,6 +933,12 @@ Status index_reader_to_capnp( auto stats_builder = reader_builder->initStats(); stats_to_capnp(stats, &stats_builder); + // Tile order + if (reader.preprocess_tile_order().enabled_) { + auto preprocess = reader_builder->initPreprocess(); + preprocess.setCursor(reader.preprocess_tile_order().cursor_); + } + return Status::Ok(); } @@ -1166,6 +1172,11 @@ Status index_reader_from_capnp( reader->set_stats(stats_data); } + if (reader_reader.hasPreprocess()) { + reader->set_preprocess_tile_order_cursor( + reader_reader.getPreprocess().getCursor()); + } + return Status::Ok(); } diff --git a/tiledb/sm/serialization/tiledb-rest.capnp b/tiledb/sm/serialization/tiledb-rest.capnp index 2d30e7528a2..e8083d01e79 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp +++ b/tiledb/sm/serialization/tiledb-rest.capnp @@ -707,6 +707,10 @@ struct ReadStateIndex { # Is the reader done adding result tiles. } +struct PreprocessTileOrder { + cursor @0 :UInt64; +} + struct ReaderIndex { # Reader struct for indexed readers. @@ -724,6 +728,8 @@ struct ReaderIndex { stats @4 :Stats; # Stats object + + preprocess @5 :PreprocessTileOrder; } struct Query { diff --git a/tiledb/sm/serialization/tiledb-rest.capnp.c++ b/tiledb/sm/serialization/tiledb-rest.capnp.c++ index 874fe7ebe0d..d7a41345c17 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp.c++ +++ b/tiledb/sm/serialization/tiledb-rest.capnp.c++ @@ -5462,17 +5462,62 @@ const ::capnp::_::RawSchema s_c86c77b5f6a2bf0f = { 2, 3, i_c86c77b5f6a2bf0f, nullptr, nullptr, { &s_c86c77b5f6a2bf0f, nullptr, nullptr, 0, 0, nullptr }, false }; #endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<96> b_9b9a5fc7713a8692 = { +static const ::capnp::_::AlignedData<34> b_818a8600b3452aa4 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 164, 42, 69, 179, 0, 134, 138, 129, + 18, 0, 0, 0, 1, 0, 1, 0, + 127, 216, 135, 181, 36, 146, 125, 181, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 50, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 105, 108, 101, 100, 98, 45, 114, + 101, 115, 116, 46, 99, 97, 112, 110, + 112, 58, 80, 114, 101, 112, 114, 111, + 99, 101, 115, 115, 84, 105, 108, 101, + 79, 114, 100, 101, 114, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 99, 117, 114, 115, 111, 114, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_818a8600b3452aa4 = b_818a8600b3452aa4.words; +#if !CAPNP_LITE +static const uint16_t m_818a8600b3452aa4[] = {0}; +static const uint16_t i_818a8600b3452aa4[] = {0}; +const ::capnp::_::RawSchema s_818a8600b3452aa4 = { + 0x818a8600b3452aa4, b_818a8600b3452aa4.words, 34, nullptr, m_818a8600b3452aa4, + 0, 1, i_818a8600b3452aa4, nullptr, nullptr, { &s_818a8600b3452aa4, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<112> b_9b9a5fc7713a8692 = { { 0, 0, 0, 0, 5, 0, 6, 0, 146, 134, 58, 113, 199, 95, 154, 155, 18, 0, 0, 0, 1, 0, 0, 0, 127, 216, 135, 181, 36, 146, 125, 181, - 5, 0, 7, 0, 0, 0, 0, 0, + 6, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 0, 242, 0, 0, 0, 33, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 29, 0, 0, 0, 31, 1, 0, 0, + 29, 0, 0, 0, 87, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 116, 105, 108, 101, 100, 98, 45, 114, @@ -5480,42 +5525,49 @@ static const ::capnp::_::AlignedData<96> b_9b9a5fc7713a8692 = { 112, 58, 82, 101, 97, 100, 101, 114, 73, 110, 100, 101, 120, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, - 20, 0, 0, 0, 3, 0, 4, 0, + 24, 0, 0, 0, 3, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 125, 0, 0, 0, 58, 0, 0, 0, + 153, 0, 0, 0, 58, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 120, 0, 0, 0, 3, 0, 1, 0, - 132, 0, 0, 0, 2, 0, 1, 0, + 148, 0, 0, 0, 3, 0, 1, 0, + 160, 0, 0, 0, 2, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 0, 0, 0, 74, 0, 0, 0, + 157, 0, 0, 0, 74, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 128, 0, 0, 0, 3, 0, 1, 0, - 140, 0, 0, 0, 2, 0, 1, 0, + 156, 0, 0, 0, 3, 0, 1, 0, + 168, 0, 0, 0, 2, 0, 1, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 137, 0, 0, 0, 82, 0, 0, 0, + 165, 0, 0, 0, 82, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 136, 0, 0, 0, 3, 0, 1, 0, - 148, 0, 0, 0, 2, 0, 1, 0, + 164, 0, 0, 0, 3, 0, 1, 0, + 176, 0, 0, 0, 2, 0, 1, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 1, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 145, 0, 0, 0, 82, 0, 0, 0, + 173, 0, 0, 0, 82, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 144, 0, 0, 0, 3, 0, 1, 0, - 156, 0, 0, 0, 2, 0, 1, 0, + 172, 0, 0, 0, 3, 0, 1, 0, + 184, 0, 0, 0, 2, 0, 1, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 153, 0, 0, 0, 50, 0, 0, 0, + 181, 0, 0, 0, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 148, 0, 0, 0, 3, 0, 1, 0, - 160, 0, 0, 0, 2, 0, 1, 0, + 176, 0, 0, 0, 3, 0, 1, 0, + 188, 0, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 185, 0, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 184, 0, 0, 0, 3, 0, 1, 0, + 196, 0, 0, 0, 2, 0, 1, 0, 108, 97, 121, 111, 117, 116, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5556,6 +5608,15 @@ static const ::capnp::_::AlignedData<96> b_9b9a5fc7713a8692 = { 164, 161, 6, 21, 161, 54, 224, 199, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 114, 101, 112, 114, 111, 99, 101, + 115, 115, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 164, 42, 69, 179, 0, 134, 138, 129, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, } @@ -5563,16 +5624,17 @@ static const ::capnp::_::AlignedData<96> b_9b9a5fc7713a8692 = { ::capnp::word const* const bp_9b9a5fc7713a8692 = b_9b9a5fc7713a8692.words; #if !CAPNP_LITE static const ::capnp::_::RawSchema* const d_9b9a5fc7713a8692[] = { + &s_818a8600b3452aa4, &s_c7e036a11506a1a4, &s_c86c77b5f6a2bf0f, &s_dba20dec138adac9, &s_eaf57cb9871fc06f, }; -static const uint16_t m_9b9a5fc7713a8692[] = {3, 0, 2, 4, 1}; -static const uint16_t i_9b9a5fc7713a8692[] = {0, 1, 2, 3, 4}; +static const uint16_t m_9b9a5fc7713a8692[] = {3, 0, 5, 2, 4, 1}; +static const uint16_t i_9b9a5fc7713a8692[] = {0, 1, 2, 3, 4, 5}; const ::capnp::_::RawSchema s_9b9a5fc7713a8692 = { - 0x9b9a5fc7713a8692, b_9b9a5fc7713a8692.words, 96, d_9b9a5fc7713a8692, m_9b9a5fc7713a8692, - 4, 5, i_9b9a5fc7713a8692, nullptr, nullptr, { &s_9b9a5fc7713a8692, nullptr, nullptr, 0, 0, nullptr }, true + 0x9b9a5fc7713a8692, b_9b9a5fc7713a8692.words, 112, d_9b9a5fc7713a8692, m_9b9a5fc7713a8692, + 5, 6, i_9b9a5fc7713a8692, nullptr, nullptr, { &s_9b9a5fc7713a8692, nullptr, nullptr, 0, 0, nullptr }, true }; #endif // !CAPNP_LITE static const ::capnp::_::AlignedData<387> b_96ba49d0f8b23ccc = { @@ -11235,6 +11297,18 @@ constexpr ::capnp::_::RawSchema const* ReadStateIndex::_capnpPrivate::schema; #endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL #endif // !CAPNP_LITE +// PreprocessTileOrder +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t PreprocessTileOrder::_capnpPrivate::dataWordSize; +constexpr uint16_t PreprocessTileOrder::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind PreprocessTileOrder::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* PreprocessTileOrder::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + // ReaderIndex #if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL constexpr uint16_t ReaderIndex::_capnpPrivate::dataWordSize; diff --git a/tiledb/sm/serialization/tiledb-rest.capnp.h b/tiledb/sm/serialization/tiledb-rest.capnp.h index 011410d65e7..5ad64933564 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp.h +++ b/tiledb/sm/serialization/tiledb-rest.capnp.h @@ -7,13 +7,12 @@ #include #ifndef CAPNP_VERSION -#error \ - "CAPNP_VERSION is not defined, is capnp/generated-header-support.h missing?" +#error "CAPNP_VERSION is not defined, is capnp/generated-header-support.h missing?" #elif CAPNP_VERSION != 1000002 -#error \ - "Version mismatch between generated code and library headers. You must use the same version of the Cap'n Proto compiler and library." +#error "Version mismatch between generated code and library headers. You must use the same version of the Cap'n Proto compiler and library." #endif + CAPNP_BEGIN_HEADER namespace capnp { @@ -69,6 +68,7 @@ CAPNP_DECLARE_SCHEMA(d74f5fed155d316c); CAPNP_DECLARE_SCHEMA(def87cead82188e7); CAPNP_DECLARE_SCHEMA(c1a2d010de779de5); CAPNP_DECLARE_SCHEMA(c86c77b5f6a2bf0f); +CAPNP_DECLARE_SCHEMA(818a8600b3452aa4); CAPNP_DECLARE_SCHEMA(9b9a5fc7713a8692); CAPNP_DECLARE_SCHEMA(96ba49d0f8b23ccc); CAPNP_DECLARE_SCHEMA(9df6f2a42c4e5f0b); @@ -118,7 +118,7 @@ CAPNP_DECLARE_SCHEMA(e193f1f45a9f102e); CAPNP_DECLARE_SCHEMA(fafb9c94c6b54ec9); CAPNP_DECLARE_SCHEMA(ce64eabcdabb02b5); CAPNP_DECLARE_SCHEMA(f3bb391da5271019); -enum class ObjectType_f3bb391da5271019 : uint16_t { +enum class ObjectType_f3bb391da5271019: uint16_t { ARRAY, GROUP, }; @@ -142,11 +142,9 @@ struct DomainArray { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(ce5904e6f9410cec, 0, 10) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -159,11 +157,9 @@ struct KV { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(e3dadf2bf211bc97, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -176,11 +172,9 @@ struct Config { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(b6c95b4b8111ad36, 0, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -193,11 +187,9 @@ struct Array { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a45730f57e0460b4, 3, 8) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -210,11 +202,9 @@ struct ArrayOpen { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(facceeafd4472c68, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -227,11 +217,9 @@ struct ArraySchema { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d71de32f98e296fe, 2, 16) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -244,11 +232,9 @@ struct DimensionLabel { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(ceff8d62d10cd1de, 2, 6) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -261,11 +247,9 @@ struct ArraySchemaEvolution { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a1b81d67548230d4, 0, 7) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -278,11 +262,9 @@ struct Attribute { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(92ad78f56de3d76a, 1, 6) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -295,11 +277,9 @@ struct Enumeration { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d00b2f19cc21b9b4, 1, 5) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -312,11 +292,9 @@ struct AttributeBufferHeader { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d20a578112fa92a2, 6, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -330,11 +308,9 @@ struct Dimension { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(95e26a84d32d8223, 2, 4) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -344,7 +320,7 @@ struct Dimension::TileExtent { class Reader; class Builder; class Pipeline; - enum Which : uint16_t { + enum Which: uint16_t { INT8, UINT8, INT16, @@ -359,11 +335,9 @@ struct Dimension::TileExtent { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a2a652536db09fa0, 2, 4) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -376,11 +350,9 @@ struct Domain { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(de030f447664754c, 0, 4) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -393,11 +365,9 @@ struct Error { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(fa787661cd3563a4, 1, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -410,11 +380,9 @@ struct FloatScaleConfig { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(fda1cb9663a55b70, 3, 0) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -427,11 +395,9 @@ struct WebpConfig { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(fd5825d8c6e74d78, 2, 0) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -445,11 +411,9 @@ struct Filter { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(e7175047415b3f97, 2, 4) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -459,7 +423,7 @@ struct Filter::Data { class Reader; class Builder; class Pipeline; - enum Which : uint16_t { + enum Which: uint16_t { TEXT, BYTES, INT8, @@ -476,11 +440,9 @@ struct Filter::Data { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(9ceaf832b3ab897f, 2, 4) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -493,17 +455,13 @@ struct FilterPipeline { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(bc4583f733eac4f5, 0, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; -template < - typename Key = ::capnp::AnyPointer, - typename Value = ::capnp::AnyPointer> +template struct Map { Map() = delete; @@ -514,15 +472,13 @@ struct Map { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(f179c194ae71718c, 0, 1) -#if !CAPNP_LITE + #if !CAPNP_LITE static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; static const ::capnp::_::RawBrandedSchema::Dependency brandDependencies[]; static const ::capnp::_::RawBrandedSchema specificBrand; - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return ::capnp::_::ChooseBrand<_capnpPrivate, Key, Value>::brand(); - } -#endif // !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, Key, Value>::brand(); } + #endif // !CAPNP_LITE }; }; @@ -536,14 +492,12 @@ struct Map::Entry { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(db5514c8aaf6faea, 0, 2) -#if !CAPNP_LITE + #if !CAPNP_LITE static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; static const ::capnp::_::RawBrandedSchema specificBrand; - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return ::capnp::_::ChooseBrand<_capnpPrivate, Key, Value>::brand(); - } -#endif // !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, Key, Value>::brand(); } + #endif // !CAPNP_LITE }; }; @@ -557,11 +511,9 @@ struct MapEnumeration { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a9d01efb4b5d8599, 0, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -574,11 +526,9 @@ struct MapEnumeration::Entry { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(ff915a194348206a, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -592,11 +542,9 @@ struct MapUInt32 { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(c6b5bb09d4611252, 0, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -609,11 +557,9 @@ struct MapUInt32::Entry { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(884e0a5f2521a5c6, 1, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -627,11 +573,9 @@ struct MapInt64 { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a83707d3ba24dd32, 0, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -644,11 +588,9 @@ struct MapInt64::Entry { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a9caccb4333a2baf, 1, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -662,11 +604,9 @@ struct MapUInt64 { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d3c5983c670e0f42, 0, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -679,11 +619,9 @@ struct MapUInt64::Entry { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(82d7452da7cd249a, 1, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -697,11 +635,9 @@ struct MapFloat64 { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(9354174d952207d2, 0, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -714,11 +650,9 @@ struct MapFloat64::Entry { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(bb80cdbc3f312934, 1, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -731,11 +665,9 @@ struct Stats { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(c7e036a11506a1a4, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -748,11 +680,9 @@ struct UnorderedWriterState { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(8bf6c1d37e748294, 1, 3) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -765,11 +695,9 @@ struct Writer { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(8ba60147a0e6735e, 1, 5) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -782,11 +710,9 @@ struct SubarrayRanges { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(86cfc12d74ed4aa0, 1, 4) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -799,11 +725,9 @@ struct LabelSubarrayRanges { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(f7aa276767b422e7, 1, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -816,11 +740,9 @@ struct Subarray { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(dba20dec138adac9, 1, 6) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -835,11 +757,9 @@ struct SubarrayPartitioner { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(ff14003c70494585, 3, 5) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -852,11 +772,9 @@ struct SubarrayPartitioner::PartitionInfo { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(f86b7bf97823250f, 3, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -869,11 +787,9 @@ struct SubarrayPartitioner::State { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(fdd9e47288724221, 2, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -886,11 +802,9 @@ struct ReadState { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(cbe1e7c13508aa2c, 1, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -903,11 +817,9 @@ struct ConditionClause { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(dac6a7f675c57409, 1, 3) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -920,11 +832,9 @@ struct ASTNode { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(afc739d5c01e6496, 1, 6) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -937,11 +847,9 @@ struct Condition { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(eaf57cb9871fc06f, 0, 3) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -954,11 +862,9 @@ struct QueryReader { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(e19754f813ccf79c, 1, 5) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -971,11 +877,9 @@ struct Delete { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d74f5fed155d316c, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -988,11 +892,9 @@ struct ResultCellSlab { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(def87cead82188e7, 4, 0) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1005,11 +907,9 @@ struct FragmentIndex { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(c1a2d010de779de5, 2, 0) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1022,11 +922,24 @@ struct ReadStateIndex { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(c86c77b5f6a2bf0f, 1, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE + }; +}; + +struct PreprocessTileOrder { + PreprocessTileOrder() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(818a8600b3452aa4, 1, 0) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1038,12 +951,10 @@ struct ReaderIndex { class Pipeline; struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(9b9a5fc7713a8692, 0, 5) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + CAPNP_DECLARE_STRUCT_HEADER(9b9a5fc7713a8692, 0, 6) + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1056,11 +967,9 @@ struct Query { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(96ba49d0f8b23ccc, 4, 17) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1073,11 +982,9 @@ struct NonEmptyDomain { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(9df6f2a42c4e5f0b, 1, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1090,11 +997,9 @@ struct NonEmptyDomainList { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a18264549448ece3, 0, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1107,11 +1012,9 @@ struct AttributeBufferSize { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(9be1921b07e6cd2d, 3, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1125,11 +1028,9 @@ struct ArrayMetadata { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(9737dcafdfce31bb, 0, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1142,11 +1043,9 @@ struct ArrayMetadata::MetadataEntry { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(926fe1c3b12ed651, 1, 3) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1161,11 +1060,9 @@ struct ArrayDirectory { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(9317f20ce509d918, 2, 12) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1178,11 +1075,9 @@ struct ArrayDirectory::TimestampedURI { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d9d27c082dec9e26, 2, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1195,11 +1090,9 @@ struct ArrayDirectory::DeleteAndUpdateTileLocation { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(9eb745af522d087c, 1, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1214,11 +1107,9 @@ struct EstimatedResultSize { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(8cd4e323f1feea3b, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1231,11 +1122,9 @@ struct EstimatedResultSize::ResultSize { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(92c8467685565269, 3, 0) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1248,11 +1137,9 @@ struct EstimatedResultSize::MemorySize { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(bda7916926591c22, 3, 0) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1265,11 +1152,9 @@ struct FragmentInfoRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(c95970eb9310dc9c, 0, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1282,11 +1167,9 @@ struct SingleFragmentInfo { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d42e7b38b33e3d29, 1, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1299,11 +1182,9 @@ struct FragmentInfo { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a000530ab1d17816, 0, 4) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1316,11 +1197,9 @@ struct GroupMetadata { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(838188de0fd57580, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1333,11 +1212,9 @@ struct GroupMember { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(c41bcc7e8cc58f18, 1, 3) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1351,11 +1228,9 @@ struct Group { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(dcdd20e1b79e915a, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1368,11 +1243,9 @@ struct Group::GroupDetails { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a2ea10c715b475c1, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1386,11 +1259,9 @@ struct GroupUpdate { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(c4e54a63294eddb7, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1403,11 +1274,9 @@ struct GroupUpdate::GroupUpdateDetails { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(83b01e46759bde40, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1421,11 +1290,9 @@ struct GroupCreate { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(fb7f36ad4d8ffe84, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1438,11 +1305,9 @@ struct GroupCreate::GroupCreateDetails { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d5fd459ad75e86a9, 0, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1455,11 +1320,9 @@ struct GlobalWriteState { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(c0c730b5390f4427, 1, 4) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1472,11 +1335,9 @@ struct SingleCoord { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d8bd3c0dec37b773, 0, 3) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1490,11 +1351,9 @@ struct FragmentMetadata { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(cde352fc27e7ca61, 4, 23) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1507,11 +1366,9 @@ struct FragmentMetadata::GenericTileOffsets { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(89aa8f4e88036b9e, 3, 8) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1524,11 +1381,9 @@ struct MultiPartUploadState { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d492b6734d5e3bf5, 1, 4) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1541,11 +1396,9 @@ struct CompletedPart { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(bde8ebd7b13d8625, 1, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1558,11 +1411,9 @@ struct WrittenFragmentInfo { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a736c51d292ca752, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1575,11 +1426,9 @@ struct BufferedChunk { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(cd8abc9dabc4b03f, 1, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1592,11 +1441,9 @@ struct ArrayDeleteFragmentsListRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(cfea684b4bcd0721, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1609,11 +1456,9 @@ struct ArrayDeleteFragmentsTimestampsRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(aaeeafe1e9f3ea1c, 2, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1626,11 +1471,9 @@ struct ArrayConsolidationRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(f5a35661031194d2, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1643,11 +1486,9 @@ struct ArrayVacuumRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(e68edfc0939e63df, 0, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1660,11 +1501,9 @@ struct LoadEnumerationsRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(891a70a671f15cf6, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1677,11 +1516,9 @@ struct LoadEnumerationsResponse { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(805c080c10c1e959, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1694,11 +1531,9 @@ struct LoadArraySchemaRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(83f094010132ff21, 1, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1711,11 +1546,9 @@ struct LoadArraySchemaResponse { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(ebe17f59ac9a1df1, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1728,11 +1561,9 @@ struct QueryPlanRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(e06f571aa93eb314, 0, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1745,11 +1576,9 @@ struct QueryPlanResponse { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(9fd8fc2f462b2d06, 0, 5) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1762,11 +1591,9 @@ struct ConsolidationPlanRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(8965edf5597ce627, 1, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1779,11 +1606,9 @@ struct ConsolidationPlanResponse { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(aac8bf9b5211388b, 0, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1796,11 +1621,9 @@ struct QueryChannel { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(ca2d4d0bfe4ae5d9, 1, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1813,11 +1636,9 @@ struct Aggregate { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(e193f1f45a9f102e, 0, 3) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1827,18 +1648,16 @@ struct CurrentDomain { class Reader; class Builder; class Pipeline; - enum Which : uint16_t { + enum Which: uint16_t { EMPTY_CURRENT_DOMAIN, ND_RECTANGLE, }; struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(fafb9c94c6b54ec9, 1, 2) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1851,11 +1670,9 @@ struct NDRectangle { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(ce64eabcdabb02b5, 0, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; @@ -1870,24 +1687,20 @@ struct ObjectInfoResponse { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(87f0466598bb29be, 1, 0) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE + #if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } + #endif // !CAPNP_LITE }; }; // ======================================================================================= class DomainArray::Reader { - public: +public: typedef DomainArray Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -1900,46 +1713,36 @@ class DomainArray::Reader { #endif // !CAPNP_LITE inline bool hasInt8() const; - inline ::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>::Reader getInt8() - const; + inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Reader getInt8() const; inline bool hasUint8() const; - inline ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader getUint8() - const; + inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader getUint8() const; inline bool hasInt16() const; - inline ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>::Reader getInt16() - const; + inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Reader getInt16() const; inline bool hasUint16() const; - inline ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader getUint16() - const; + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader getUint16() const; inline bool hasInt32() const; - inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Reader getInt32() - const; + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader getInt32() const; inline bool hasUint32() const; - inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader getUint32() - const; + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader getUint32() const; inline bool hasInt64() const; - inline ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>::Reader getInt64() - const; + inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader getInt64() const; inline bool hasUint64() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getUint64() - const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getUint64() const; inline bool hasFloat32() const; - inline ::capnp::List::Reader getFloat32() - const; + inline ::capnp::List::Reader getFloat32() const; inline bool hasFloat64() const; - inline ::capnp::List::Reader getFloat64() - const; + inline ::capnp::List::Reader getFloat64() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -1952,164 +1755,102 @@ class DomainArray::Reader { }; class DomainArray::Builder { - public: +public: typedef DomainArray Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasInt8(); - inline ::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>::Builder getInt8(); - inline void setInt8( - ::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setInt8(::kj::ArrayPtr value); - inline ::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>::Builder initInt8( - unsigned int size); - inline void adoptInt8( - ::capnp::Orphan<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>> - disownInt8(); + inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Builder getInt8(); + inline void setInt8( ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInt8(::kj::ArrayPtr value); + inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Builder initInt8(unsigned int size); + inline void adoptInt8(::capnp::Orphan< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>> disownInt8(); inline bool hasUint8(); - inline ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder getUint8(); - inline void setUint8( - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setUint8(::kj::ArrayPtr value); - inline ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder initUint8( - unsigned int size); - inline void adoptUint8( - ::capnp::Orphan<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>> - disownUint8(); + inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder getUint8(); + inline void setUint8( ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUint8(::kj::ArrayPtr value); + inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder initUint8(unsigned int size); + inline void adoptUint8(::capnp::Orphan< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>> disownUint8(); inline bool hasInt16(); - inline ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>::Builder getInt16(); - inline void setInt16( - ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setInt16(::kj::ArrayPtr value); - inline ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>::Builder initInt16( - unsigned int size); - inline void adoptInt16( - ::capnp::Orphan<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>> - disownInt16(); + inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Builder getInt16(); + inline void setInt16( ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInt16(::kj::ArrayPtr value); + inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Builder initInt16(unsigned int size); + inline void adoptInt16(::capnp::Orphan< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>> disownInt16(); inline bool hasUint16(); - inline ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder - getUint16(); - inline void setUint16( - ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setUint16(::kj::ArrayPtr value); - inline ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder - initUint16(unsigned int size); - inline void adoptUint16( - ::capnp::Orphan<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>> - disownUint16(); + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder getUint16(); + inline void setUint16( ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUint16(::kj::ArrayPtr value); + inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder initUint16(unsigned int size); + inline void adoptUint16(::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>> disownUint16(); inline bool hasInt32(); - inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Builder getInt32(); - inline void setInt32( - ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setInt32(::kj::ArrayPtr value); - inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Builder initInt32( - unsigned int size); - inline void adoptInt32( - ::capnp::Orphan<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>> - disownInt32(); + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder getInt32(); + inline void setInt32( ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInt32(::kj::ArrayPtr value); + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder initInt32(unsigned int size); + inline void adoptInt32(::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>> disownInt32(); inline bool hasUint32(); - inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder - getUint32(); - inline void setUint32( - ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setUint32(::kj::ArrayPtr value); - inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder - initUint32(unsigned int size); - inline void adoptUint32( - ::capnp::Orphan<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>> - disownUint32(); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder getUint32(); + inline void setUint32( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUint32(::kj::ArrayPtr value); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder initUint32(unsigned int size); + inline void adoptUint32(::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> disownUint32(); inline bool hasInt64(); - inline ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>::Builder getInt64(); - inline void setInt64( - ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setInt64(::kj::ArrayPtr value); - inline ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>::Builder initInt64( - unsigned int size); - inline void adoptInt64( - ::capnp::Orphan<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>> - disownInt64(); + inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder getInt64(); + inline void setInt64( ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInt64(::kj::ArrayPtr value); + inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder initInt64(unsigned int size); + inline void adoptInt64(::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>> disownInt64(); inline bool hasUint64(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getUint64(); - inline void setUint64( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setUint64(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initUint64(unsigned int size); - inline void adoptUint64( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownUint64(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getUint64(); + inline void setUint64( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUint64(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initUint64(unsigned int size); + inline void adoptUint64(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownUint64(); inline bool hasFloat32(); - inline ::capnp::List::Builder getFloat32(); - inline void setFloat32( - ::capnp::List::Reader value); + inline ::capnp::List::Builder getFloat32(); + inline void setFloat32( ::capnp::List::Reader value); inline void setFloat32(::kj::ArrayPtr value); - inline ::capnp::List::Builder initFloat32( - unsigned int size); - inline void adoptFloat32( - ::capnp::Orphan<::capnp::List>&& value); - inline ::capnp::Orphan<::capnp::List> - disownFloat32(); + inline ::capnp::List::Builder initFloat32(unsigned int size); + inline void adoptFloat32(::capnp::Orphan< ::capnp::List>&& value); + inline ::capnp::Orphan< ::capnp::List> disownFloat32(); inline bool hasFloat64(); - inline ::capnp::List::Builder getFloat64(); - inline void setFloat64( - ::capnp::List::Reader value); + inline ::capnp::List::Builder getFloat64(); + inline void setFloat64( ::capnp::List::Reader value); inline void setFloat64(::kj::ArrayPtr value); - inline ::capnp::List::Builder initFloat64( - unsigned int size); - inline void adoptFloat64( - ::capnp::Orphan<::capnp::List>&& value); - inline ::capnp::Orphan<::capnp::List> - disownFloat64(); - - private: + inline ::capnp::List::Builder initFloat64(unsigned int size); + inline void adoptFloat64(::capnp::Orphan< ::capnp::List>&& value); + inline ::capnp::Orphan< ::capnp::List> disownFloat64(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -2120,17 +1861,14 @@ class DomainArray::Builder { #if !CAPNP_LITE class DomainArray::Pipeline { - public: +public: typedef DomainArray Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -2139,13 +1877,11 @@ class DomainArray::Pipeline { #endif // !CAPNP_LITE class KV::Reader { - public: +public: typedef KV Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -2158,12 +1894,12 @@ class KV::Reader { #endif // !CAPNP_LITE inline bool hasKey() const; - inline ::capnp::Text::Reader getKey() const; + inline ::capnp::Text::Reader getKey() const; inline bool hasValue() const; - inline ::capnp::Text::Reader getValue() const; + inline ::capnp::Text::Reader getValue() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -2176,47 +1912,36 @@ class KV::Reader { }; class KV::Builder { - public: +public: typedef KV Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasKey(); - inline ::capnp::Text::Builder getKey(); - inline void setKey(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initKey(unsigned int size); - inline void adoptKey(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownKey(); + inline ::capnp::Text::Builder getKey(); + inline void setKey( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initKey(unsigned int size); + inline void adoptKey(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownKey(); inline bool hasValue(); - inline ::capnp::Text::Builder getValue(); - inline void setValue(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initValue(unsigned int size); - inline void adoptValue(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownValue(); + inline ::capnp::Text::Builder getValue(); + inline void setValue( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initValue(unsigned int size); + inline void adoptValue(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownValue(); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -2227,17 +1952,14 @@ class KV::Builder { #if !CAPNP_LITE class KV::Pipeline { - public: +public: typedef KV Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -2246,13 +1968,11 @@ class KV::Pipeline { #endif // !CAPNP_LITE class Config::Reader { - public: +public: typedef Config Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -2265,12 +1985,9 @@ class Config::Reader { #endif // !CAPNP_LITE inline bool hasEntries() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>::Reader - getEntries() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader getEntries() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -2283,53 +2000,29 @@ class Config::Reader { }; class Config::Builder { - public: +public: typedef Config Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasEntries(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>::Builder - getEntries(); - inline void setEntries(::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>::Builder - initEntries(unsigned int size); - inline void adoptEntries(::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>> - disownEntries(); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder getEntries(); + inline void setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder initEntries(unsigned int size); + inline void adoptEntries(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>> disownEntries(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -2340,17 +2033,14 @@ class Config::Builder { #if !CAPNP_LITE class Config::Pipeline { - public: +public: typedef Config Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -2359,13 +2049,11 @@ class Config::Pipeline { #endif // !CAPNP_LITE class Array::Reader { - public: +public: typedef Array Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -2377,47 +2065,37 @@ class Array::Reader { } #endif // !CAPNP_LITE - inline ::uint64_t getEndTimestamp() const; + inline ::uint64_t getEndTimestamp() const; inline bool hasQueryType() const; - inline ::capnp::Text::Reader getQueryType() const; + inline ::capnp::Text::Reader getQueryType() const; inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; - inline ::uint64_t getStartTimestamp() const; + inline ::uint64_t getStartTimestamp() const; inline bool hasArraySchemaLatest() const; - inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader - getArraySchemaLatest() const; + inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader getArraySchemaLatest() const; inline bool hasArraySchemasAll() const; - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Reader - getArraySchemasAll() const; + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader getArraySchemasAll() const; inline bool hasNonEmptyDomain() const; - inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader - getNonEmptyDomain() const; + inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader getNonEmptyDomain() const; inline bool hasArrayMetadata() const; - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader - getArrayMetadata() const; + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader getArrayMetadata() const; inline bool hasArrayDirectory() const; - inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Reader - getArrayDirectory() const; + inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Reader getArrayDirectory() const; inline bool hasFragmentMetadataAll() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>::Reader - getFragmentMetadataAll() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>::Reader getFragmentMetadataAll() const; - inline ::uint64_t getOpenedAtEndTimestamp() const; + inline ::uint64_t getOpenedAtEndTimestamp() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -2430,151 +2108,87 @@ class Array::Reader { }; class Array::Builder { - public: +public: typedef Array Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE - inline ::uint64_t getEndTimestamp(); - inline void setEndTimestamp(::uint64_t value); + inline ::uint64_t getEndTimestamp(); + inline void setEndTimestamp( ::uint64_t value); inline bool hasQueryType(); - inline ::capnp::Text::Builder getQueryType(); - inline void setQueryType(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initQueryType(unsigned int size); - inline void adoptQueryType(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownQueryType(); + inline ::capnp::Text::Builder getQueryType(); + inline void setQueryType( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initQueryType(unsigned int size); + inline void adoptQueryType(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownQueryType(); inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownUri(); - inline ::uint64_t getStartTimestamp(); - inline void setStartTimestamp(::uint64_t value); + inline ::uint64_t getStartTimestamp(); + inline void setStartTimestamp( ::uint64_t value); inline bool hasArraySchemaLatest(); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder - getArraySchemaLatest(); - inline void setArraySchemaLatest( - ::tiledb::sm::serialization::capnp::ArraySchema::Reader value); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder - initArraySchemaLatest(); - inline void adoptArraySchemaLatest( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema> - disownArraySchemaLatest(); + inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder getArraySchemaLatest(); + inline void setArraySchemaLatest( ::tiledb::sm::serialization::capnp::ArraySchema::Reader value); + inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder initArraySchemaLatest(); + inline void adoptArraySchemaLatest(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema> disownArraySchemaLatest(); inline bool hasArraySchemasAll(); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Builder - getArraySchemasAll(); - inline void setArraySchemasAll( - ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Builder - initArraySchemasAll(); - inline void adoptArraySchemasAll( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>> - disownArraySchemasAll(); + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder getArraySchemasAll(); + inline void setArraySchemasAll( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value); + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder initArraySchemasAll(); + inline void adoptArraySchemasAll(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>> disownArraySchemasAll(); inline bool hasNonEmptyDomain(); - inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder - getNonEmptyDomain(); - inline void setNonEmptyDomain( - ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader value); - inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder - initNonEmptyDomain(); - inline void adoptNonEmptyDomain( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::NonEmptyDomainList>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::NonEmptyDomainList> - disownNonEmptyDomain(); + inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder getNonEmptyDomain(); + inline void setNonEmptyDomain( ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader value); + inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder initNonEmptyDomain(); + inline void adoptNonEmptyDomain(::capnp::Orphan< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NonEmptyDomainList> disownNonEmptyDomain(); inline bool hasArrayMetadata(); - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder - getArrayMetadata(); - inline void setArrayMetadata( - ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value); - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder - initArrayMetadata(); - inline void adoptArrayMetadata( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata> - disownArrayMetadata(); + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder getArrayMetadata(); + inline void setArrayMetadata( ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value); + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder initArrayMetadata(); + inline void adoptArrayMetadata(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata> disownArrayMetadata(); inline bool hasArrayDirectory(); - inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Builder - getArrayDirectory(); - inline void setArrayDirectory( - ::tiledb::sm::serialization::capnp::ArrayDirectory::Reader value); - inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Builder - initArrayDirectory(); - inline void adoptArrayDirectory( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayDirectory>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayDirectory> - disownArrayDirectory(); + inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Builder getArrayDirectory(); + inline void setArrayDirectory( ::tiledb::sm::serialization::capnp::ArrayDirectory::Reader value); + inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Builder initArrayDirectory(); + inline void adoptArrayDirectory(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayDirectory>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayDirectory> disownArrayDirectory(); inline bool hasFragmentMetadataAll(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>::Builder - getFragmentMetadataAll(); - inline void setFragmentMetadataAll( - ::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>::Builder - initFragmentMetadataAll(unsigned int size); - inline void adoptFragmentMetadataAll( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>> - disownFragmentMetadataAll(); - - inline ::uint64_t getOpenedAtEndTimestamp(); - inline void setOpenedAtEndTimestamp(::uint64_t value); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>::Builder getFragmentMetadataAll(); + inline void setFragmentMetadataAll( ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>::Builder initFragmentMetadataAll(unsigned int size); + inline void adoptFragmentMetadataAll(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>> disownFragmentMetadataAll(); + + inline ::uint64_t getOpenedAtEndTimestamp(); + inline void setOpenedAtEndTimestamp( ::uint64_t value); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -2585,30 +2199,19 @@ class Array::Builder { #if !CAPNP_LITE class Array::Pipeline { - public: +public: typedef Array Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline - getArraySchemaLatest(); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline - getArraySchemasAll(); - inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline - getNonEmptyDomain(); - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline - getArrayMetadata(); - inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Pipeline - getArrayDirectory(); - - private: + : _typeless(kj::mv(typeless)) {} + + inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline getArraySchemaLatest(); + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline getArraySchemasAll(); + inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline getNonEmptyDomain(); + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline getArrayMetadata(); + inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Pipeline getArrayDirectory(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -2617,13 +2220,11 @@ class Array::Pipeline { #endif // !CAPNP_LITE class ArrayOpen::Reader { - public: +public: typedef ArrayOpen Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -2636,12 +2237,12 @@ class ArrayOpen::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasQueryType() const; - inline ::capnp::Text::Reader getQueryType() const; + inline ::capnp::Text::Reader getQueryType() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -2654,50 +2255,36 @@ class ArrayOpen::Reader { }; class ArrayOpen::Builder { - public: +public: typedef ArrayOpen Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> - disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); inline bool hasQueryType(); - inline ::capnp::Text::Builder getQueryType(); - inline void setQueryType(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initQueryType(unsigned int size); - inline void adoptQueryType(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownQueryType(); + inline ::capnp::Text::Builder getQueryType(); + inline void setQueryType( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initQueryType(unsigned int size); + inline void adoptQueryType(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownQueryType(); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -2708,19 +2295,15 @@ class ArrayOpen::Builder { #if !CAPNP_LITE class ArrayOpen::Pipeline { - public: +public: typedef ArrayOpen Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - - private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -2729,13 +2312,11 @@ class ArrayOpen::Pipeline { #endif // !CAPNP_LITE class ArraySchema::Reader { - public: +public: typedef ArraySchema Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -2748,76 +2329,58 @@ class ArraySchema::Reader { #endif // !CAPNP_LITE inline bool hasArrayType() const; - inline ::capnp::Text::Reader getArrayType() const; + inline ::capnp::Text::Reader getArrayType() const; inline bool hasAttributes() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>::Reader - getAttributes() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Reader getAttributes() const; - inline ::uint64_t getCapacity() const; + inline ::uint64_t getCapacity() const; inline bool hasCellOrder() const; - inline ::capnp::Text::Reader getCellOrder() const; + inline ::capnp::Text::Reader getCellOrder() const; inline bool hasCoordsFilterPipeline() const; - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader - getCoordsFilterPipeline() const; + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader getCoordsFilterPipeline() const; inline bool hasDomain() const; - inline ::tiledb::sm::serialization::capnp::Domain::Reader getDomain() const; + inline ::tiledb::sm::serialization::capnp::Domain::Reader getDomain() const; inline bool hasOffsetFilterPipeline() const; - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader - getOffsetFilterPipeline() const; + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader getOffsetFilterPipeline() const; inline bool hasTileOrder() const; - inline ::capnp::Text::Reader getTileOrder() const; + inline ::capnp::Text::Reader getTileOrder() const; inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; inline bool hasVersion() const; - inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Reader getVersion() - const; + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader getVersion() const; inline bool getAllowsDuplicates() const; inline bool hasValidityFilterPipeline() const; - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader - getValidityFilterPipeline() const; + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader getValidityFilterPipeline() const; inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; inline bool hasTimestampRange() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getTimestampRange() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTimestampRange() const; inline bool hasDimensionLabels() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>::Reader - getDimensionLabels() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>::Reader getDimensionLabels() const; inline bool hasEnumerations() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader - getEnumerations() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader getEnumerations() const; inline bool hasEnumerationPathMap() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>::Reader - getEnumerationPathMap() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader getEnumerationPathMap() const; inline bool hasCurrentDomain() const; - inline ::tiledb::sm::serialization::capnp::CurrentDomain::Reader - getCurrentDomain() const; + inline ::tiledb::sm::serialization::capnp::CurrentDomain::Reader getCurrentDomain() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -2830,248 +2393,142 @@ class ArraySchema::Reader { }; class ArraySchema::Builder { - public: +public: typedef ArraySchema Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasArrayType(); - inline ::capnp::Text::Builder getArrayType(); - inline void setArrayType(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initArrayType(unsigned int size); - inline void adoptArrayType(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownArrayType(); + inline ::capnp::Text::Builder getArrayType(); + inline void setArrayType( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initArrayType(unsigned int size); + inline void adoptArrayType(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownArrayType(); inline bool hasAttributes(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>::Builder - getAttributes(); - inline void setAttributes(::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>::Builder - initAttributes(unsigned int size); - inline void adoptAttributes(::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>> - disownAttributes(); - - inline ::uint64_t getCapacity(); - inline void setCapacity(::uint64_t value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Builder getAttributes(); + inline void setAttributes( ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Builder initAttributes(unsigned int size); + inline void adoptAttributes(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>> disownAttributes(); + + inline ::uint64_t getCapacity(); + inline void setCapacity( ::uint64_t value); inline bool hasCellOrder(); - inline ::capnp::Text::Builder getCellOrder(); - inline void setCellOrder(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initCellOrder(unsigned int size); - inline void adoptCellOrder(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownCellOrder(); + inline ::capnp::Text::Builder getCellOrder(); + inline void setCellOrder( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initCellOrder(unsigned int size); + inline void adoptCellOrder(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownCellOrder(); inline bool hasCoordsFilterPipeline(); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder - getCoordsFilterPipeline(); - inline void setCoordsFilterPipeline( - ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder - initCoordsFilterPipeline(); - inline void adoptCoordsFilterPipeline( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> - disownCoordsFilterPipeline(); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder getCoordsFilterPipeline(); + inline void setCoordsFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder initCoordsFilterPipeline(); + inline void adoptCoordsFilterPipeline(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> disownCoordsFilterPipeline(); inline bool hasDomain(); - inline ::tiledb::sm::serialization::capnp::Domain::Builder getDomain(); - inline void setDomain( - ::tiledb::sm::serialization::capnp::Domain::Reader value); - inline ::tiledb::sm::serialization::capnp::Domain::Builder initDomain(); - inline void adoptDomain( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Domain>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Domain> - disownDomain(); + inline ::tiledb::sm::serialization::capnp::Domain::Builder getDomain(); + inline void setDomain( ::tiledb::sm::serialization::capnp::Domain::Reader value); + inline ::tiledb::sm::serialization::capnp::Domain::Builder initDomain(); + inline void adoptDomain(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Domain>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Domain> disownDomain(); inline bool hasOffsetFilterPipeline(); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder - getOffsetFilterPipeline(); - inline void setOffsetFilterPipeline( - ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder - initOffsetFilterPipeline(); - inline void adoptOffsetFilterPipeline( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> - disownOffsetFilterPipeline(); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder getOffsetFilterPipeline(); + inline void setOffsetFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder initOffsetFilterPipeline(); + inline void adoptOffsetFilterPipeline(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> disownOffsetFilterPipeline(); inline bool hasTileOrder(); - inline ::capnp::Text::Builder getTileOrder(); - inline void setTileOrder(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initTileOrder(unsigned int size); - inline void adoptTileOrder(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownTileOrder(); + inline ::capnp::Text::Builder getTileOrder(); + inline void setTileOrder( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initTileOrder(unsigned int size); + inline void adoptTileOrder(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownTileOrder(); inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownUri(); inline bool hasVersion(); - inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Builder - getVersion(); - inline void setVersion( - ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setVersion(::kj::ArrayPtr value); - inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Builder - initVersion(unsigned int size); - inline void adoptVersion( - ::capnp::Orphan<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>> - disownVersion(); + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder getVersion(); + inline void setVersion( ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setVersion(::kj::ArrayPtr value); + inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder initVersion(unsigned int size); + inline void adoptVersion(::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>> disownVersion(); inline bool getAllowsDuplicates(); inline void setAllowsDuplicates(bool value); inline bool hasValidityFilterPipeline(); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder - getValidityFilterPipeline(); - inline void setValidityFilterPipeline( - ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder - initValidityFilterPipeline(); - inline void adoptValidityFilterPipeline( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> - disownValidityFilterPipeline(); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder getValidityFilterPipeline(); + inline void setValidityFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder initValidityFilterPipeline(); + inline void adoptValidityFilterPipeline(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> disownValidityFilterPipeline(); inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownName(); inline bool hasTimestampRange(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getTimestampRange(); - inline void setTimestampRange( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTimestampRange(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initTimestampRange(unsigned int size); - inline void adoptTimestampRange( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownTimestampRange(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTimestampRange(); + inline void setTimestampRange( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTimestampRange(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTimestampRange(unsigned int size); + inline void adoptTimestampRange(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTimestampRange(); inline bool hasDimensionLabels(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>::Builder - getDimensionLabels(); - inline void setDimensionLabels( - ::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>::Builder - initDimensionLabels(unsigned int size); - inline void adoptDimensionLabels( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>> - disownDimensionLabels(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>::Builder getDimensionLabels(); + inline void setDimensionLabels( ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>::Builder initDimensionLabels(unsigned int size); + inline void adoptDimensionLabels(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>> disownDimensionLabels(); inline bool hasEnumerations(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder - getEnumerations(); - inline void setEnumerations(::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder - initEnumerations(unsigned int size); - inline void adoptEnumerations( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>> - disownEnumerations(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder getEnumerations(); + inline void setEnumerations( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder initEnumerations(unsigned int size); + inline void adoptEnumerations(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> disownEnumerations(); inline bool hasEnumerationPathMap(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>::Builder - getEnumerationPathMap(); - inline void setEnumerationPathMap(::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>::Builder - initEnumerationPathMap(unsigned int size); - inline void adoptEnumerationPathMap( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>> - disownEnumerationPathMap(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder getEnumerationPathMap(); + inline void setEnumerationPathMap( ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder initEnumerationPathMap(unsigned int size); + inline void adoptEnumerationPathMap(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>> disownEnumerationPathMap(); inline bool hasCurrentDomain(); - inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder - getCurrentDomain(); - inline void setCurrentDomain( - ::tiledb::sm::serialization::capnp::CurrentDomain::Reader value); - inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder - initCurrentDomain(); - inline void adoptCurrentDomain( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::CurrentDomain>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::CurrentDomain> - disownCurrentDomain(); - - private: + inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder getCurrentDomain(); + inline void setCurrentDomain( ::tiledb::sm::serialization::capnp::CurrentDomain::Reader value); + inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder initCurrentDomain(); + inline void adoptCurrentDomain(::capnp::Orphan< ::tiledb::sm::serialization::capnp::CurrentDomain>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::CurrentDomain> disownCurrentDomain(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -3082,27 +2539,19 @@ class ArraySchema::Builder { #if !CAPNP_LITE class ArraySchema::Pipeline { - public: +public: typedef ArraySchema Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline - getCoordsFilterPipeline(); - inline ::tiledb::sm::serialization::capnp::Domain::Pipeline getDomain(); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline - getOffsetFilterPipeline(); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline - getValidityFilterPipeline(); - inline ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline - getCurrentDomain(); - - private: + : _typeless(kj::mv(typeless)) {} + + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline getCoordsFilterPipeline(); + inline ::tiledb::sm::serialization::capnp::Domain::Pipeline getDomain(); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline getOffsetFilterPipeline(); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline getValidityFilterPipeline(); + inline ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline getCurrentDomain(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -3111,13 +2560,11 @@ class ArraySchema::Pipeline { #endif // !CAPNP_LITE class DimensionLabel::Reader { - public: +public: typedef DimensionLabel Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -3129,34 +2576,33 @@ class DimensionLabel::Reader { } #endif // !CAPNP_LITE - inline ::uint32_t getDimensionId() const; + inline ::uint32_t getDimensionId() const; inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; inline bool hasAttributeName() const; - inline ::capnp::Text::Reader getAttributeName() const; + inline ::capnp::Text::Reader getAttributeName() const; inline bool hasOrder() const; - inline ::capnp::Text::Reader getOrder() const; + inline ::capnp::Text::Reader getOrder() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; - inline ::uint32_t getCellValNum() const; + inline ::uint32_t getCellValNum() const; inline bool getExternal() const; inline bool getRelative() const; inline bool hasSchema() const; - inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader getSchema() - const; + inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader getSchema() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -3169,72 +2615,61 @@ class DimensionLabel::Reader { }; class DimensionLabel::Builder { - public: +public: typedef DimensionLabel Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE - inline ::uint32_t getDimensionId(); - inline void setDimensionId(::uint32_t value); + inline ::uint32_t getDimensionId(); + inline void setDimensionId( ::uint32_t value); inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownName(); inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownUri(); inline bool hasAttributeName(); - inline ::capnp::Text::Builder getAttributeName(); - inline void setAttributeName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initAttributeName(unsigned int size); - inline void adoptAttributeName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownAttributeName(); + inline ::capnp::Text::Builder getAttributeName(); + inline void setAttributeName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initAttributeName(unsigned int size); + inline void adoptAttributeName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownAttributeName(); inline bool hasOrder(); - inline ::capnp::Text::Builder getOrder(); - inline void setOrder(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initOrder(unsigned int size); - inline void adoptOrder(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownOrder(); + inline ::capnp::Text::Builder getOrder(); + inline void setOrder( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initOrder(unsigned int size); + inline void adoptOrder(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownOrder(); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownType(); - inline ::uint32_t getCellValNum(); - inline void setCellValNum(::uint32_t value); + inline ::uint32_t getCellValNum(); + inline void setCellValNum( ::uint32_t value); inline bool getExternal(); inline void setExternal(bool value); @@ -3243,16 +2678,13 @@ class DimensionLabel::Builder { inline void setRelative(bool value); inline bool hasSchema(); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder getSchema(); - inline void setSchema( - ::tiledb::sm::serialization::capnp::ArraySchema::Reader value); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder initSchema(); - inline void adoptSchema( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema> - disownSchema(); - - private: + inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder getSchema(); + inline void setSchema( ::tiledb::sm::serialization::capnp::ArraySchema::Reader value); + inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder initSchema(); + inline void adoptSchema(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema> disownSchema(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -3263,19 +2695,15 @@ class DimensionLabel::Builder { #if !CAPNP_LITE class DimensionLabel::Pipeline { - public: +public: typedef DimensionLabel Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline getSchema(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline getSchema(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -3284,13 +2712,11 @@ class DimensionLabel::Pipeline { #endif // !CAPNP_LITE class ArraySchemaEvolution::Reader { - public: +public: typedef ArraySchemaEvolution Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -3303,40 +2729,27 @@ class ArraySchemaEvolution::Reader { #endif // !CAPNP_LITE inline bool hasAttributesToDrop() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getAttributesToDrop() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getAttributesToDrop() const; inline bool hasAttributesToAdd() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>::Reader - getAttributesToAdd() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Reader getAttributesToAdd() const; inline bool hasTimestampRange() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getTimestampRange() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTimestampRange() const; inline bool hasEnumerationsToAdd() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader - getEnumerationsToAdd() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader getEnumerationsToAdd() const; inline bool hasEnumerationsToDrop() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getEnumerationsToDrop() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getEnumerationsToDrop() const; inline bool hasEnumerationsToExtend() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader - getEnumerationsToExtend() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader getEnumerationsToExtend() const; inline bool hasCurrentDomainToExpand() const; - inline ::tiledb::sm::serialization::capnp::CurrentDomain::Reader - getCurrentDomainToExpand() const; + inline ::tiledb::sm::serialization::capnp::CurrentDomain::Reader getCurrentDomainToExpand() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -3349,155 +2762,74 @@ class ArraySchemaEvolution::Reader { }; class ArraySchemaEvolution::Builder { - public: +public: typedef ArraySchemaEvolution Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasAttributesToDrop(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getAttributesToDrop(); - inline void setAttributesToDrop( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setAttributesToDrop( - ::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initAttributesToDrop(unsigned int size); - inline void adoptAttributesToDrop( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownAttributesToDrop(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getAttributesToDrop(); + inline void setAttributesToDrop( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setAttributesToDrop(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initAttributesToDrop(unsigned int size); + inline void adoptAttributesToDrop(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownAttributesToDrop(); inline bool hasAttributesToAdd(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>::Builder - getAttributesToAdd(); - inline void setAttributesToAdd(::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>::Builder - initAttributesToAdd(unsigned int size); - inline void adoptAttributesToAdd( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>> - disownAttributesToAdd(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Builder getAttributesToAdd(); + inline void setAttributesToAdd( ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Builder initAttributesToAdd(unsigned int size); + inline void adoptAttributesToAdd(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>> disownAttributesToAdd(); inline bool hasTimestampRange(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getTimestampRange(); - inline void setTimestampRange( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTimestampRange(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initTimestampRange(unsigned int size); - inline void adoptTimestampRange( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownTimestampRange(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTimestampRange(); + inline void setTimestampRange( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTimestampRange(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTimestampRange(unsigned int size); + inline void adoptTimestampRange(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTimestampRange(); inline bool hasEnumerationsToAdd(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder - getEnumerationsToAdd(); - inline void setEnumerationsToAdd( - ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder - initEnumerationsToAdd(unsigned int size); - inline void adoptEnumerationsToAdd( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>> - disownEnumerationsToAdd(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder getEnumerationsToAdd(); + inline void setEnumerationsToAdd( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder initEnumerationsToAdd(unsigned int size); + inline void adoptEnumerationsToAdd(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> disownEnumerationsToAdd(); inline bool hasEnumerationsToDrop(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getEnumerationsToDrop(); - inline void setEnumerationsToDrop( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setEnumerationsToDrop( - ::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initEnumerationsToDrop(unsigned int size); - inline void adoptEnumerationsToDrop( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownEnumerationsToDrop(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getEnumerationsToDrop(); + inline void setEnumerationsToDrop( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setEnumerationsToDrop(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initEnumerationsToDrop(unsigned int size); + inline void adoptEnumerationsToDrop(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownEnumerationsToDrop(); inline bool hasEnumerationsToExtend(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder - getEnumerationsToExtend(); - inline void setEnumerationsToExtend( - ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder - initEnumerationsToExtend(unsigned int size); - inline void adoptEnumerationsToExtend( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>> - disownEnumerationsToExtend(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder getEnumerationsToExtend(); + inline void setEnumerationsToExtend( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder initEnumerationsToExtend(unsigned int size); + inline void adoptEnumerationsToExtend(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> disownEnumerationsToExtend(); inline bool hasCurrentDomainToExpand(); - inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder - getCurrentDomainToExpand(); - inline void setCurrentDomainToExpand( - ::tiledb::sm::serialization::capnp::CurrentDomain::Reader value); - inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder - initCurrentDomainToExpand(); - inline void adoptCurrentDomainToExpand( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::CurrentDomain>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::CurrentDomain> - disownCurrentDomainToExpand(); - - private: + inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder getCurrentDomainToExpand(); + inline void setCurrentDomainToExpand( ::tiledb::sm::serialization::capnp::CurrentDomain::Reader value); + inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder initCurrentDomainToExpand(); + inline void adoptCurrentDomainToExpand(::capnp::Orphan< ::tiledb::sm::serialization::capnp::CurrentDomain>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::CurrentDomain> disownCurrentDomainToExpand(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -3508,20 +2840,15 @@ class ArraySchemaEvolution::Builder { #if !CAPNP_LITE class ArraySchemaEvolution::Pipeline { - public: +public: typedef ArraySchemaEvolution Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline - getCurrentDomainToExpand(); - - private: + inline ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline getCurrentDomainToExpand(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -3530,13 +2857,11 @@ class ArraySchemaEvolution::Pipeline { #endif // !CAPNP_LITE class Attribute::Reader { - public: +public: typedef Attribute Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -3548,32 +2873,31 @@ class Attribute::Reader { } #endif // !CAPNP_LITE - inline ::uint32_t getCellValNum() const; + inline ::uint32_t getCellValNum() const; inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; inline bool hasFilterPipeline() const; - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader - getFilterPipeline() const; + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader getFilterPipeline() const; inline bool hasFillValue() const; - inline ::capnp::Data::Reader getFillValue() const; + inline ::capnp::Data::Reader getFillValue() const; inline bool getNullable() const; inline bool getFillValueValidity() const; inline bool hasOrder() const; - inline ::capnp::Text::Reader getOrder() const; + inline ::capnp::Text::Reader getOrder() const; inline bool hasEnumerationName() const; - inline ::capnp::Text::Reader getEnumerationName() const; + inline ::capnp::Text::Reader getEnumerationName() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -3586,68 +2910,51 @@ class Attribute::Reader { }; class Attribute::Builder { - public: +public: typedef Attribute Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE - inline ::uint32_t getCellValNum(); - inline void setCellValNum(::uint32_t value); + inline ::uint32_t getCellValNum(); + inline void setCellValNum( ::uint32_t value); inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownName(); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownType(); inline bool hasFilterPipeline(); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder - getFilterPipeline(); - inline void setFilterPipeline( - ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder - initFilterPipeline(); - inline void adoptFilterPipeline( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> - disownFilterPipeline(); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder getFilterPipeline(); + inline void setFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder initFilterPipeline(); + inline void adoptFilterPipeline(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> disownFilterPipeline(); inline bool hasFillValue(); - inline ::capnp::Data::Builder getFillValue(); - inline void setFillValue(::capnp::Data::Reader value); - inline ::capnp::Data::Builder initFillValue(unsigned int size); - inline void adoptFillValue(::capnp::Orphan<::capnp::Data>&& value); - inline ::capnp::Orphan<::capnp::Data> disownFillValue(); + inline ::capnp::Data::Builder getFillValue(); + inline void setFillValue( ::capnp::Data::Reader value); + inline ::capnp::Data::Builder initFillValue(unsigned int size); + inline void adoptFillValue(::capnp::Orphan< ::capnp::Data>&& value); + inline ::capnp::Orphan< ::capnp::Data> disownFillValue(); inline bool getNullable(); inline void setNullable(bool value); @@ -3656,20 +2963,20 @@ class Attribute::Builder { inline void setFillValueValidity(bool value); inline bool hasOrder(); - inline ::capnp::Text::Builder getOrder(); - inline void setOrder(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initOrder(unsigned int size); - inline void adoptOrder(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownOrder(); + inline ::capnp::Text::Builder getOrder(); + inline void setOrder( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initOrder(unsigned int size); + inline void adoptOrder(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownOrder(); inline bool hasEnumerationName(); - inline ::capnp::Text::Builder getEnumerationName(); - inline void setEnumerationName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initEnumerationName(unsigned int size); - inline void adoptEnumerationName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownEnumerationName(); + inline ::capnp::Text::Builder getEnumerationName(); + inline void setEnumerationName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initEnumerationName(unsigned int size); + inline void adoptEnumerationName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownEnumerationName(); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -3680,20 +2987,15 @@ class Attribute::Builder { #if !CAPNP_LITE class Attribute::Pipeline { - public: +public: typedef Attribute Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline - getFilterPipeline(); - - private: + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline getFilterPipeline(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -3702,13 +3004,11 @@ class Attribute::Pipeline { #endif // !CAPNP_LITE class Enumeration::Reader { - public: +public: typedef Enumeration Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -3721,25 +3021,25 @@ class Enumeration::Reader { #endif // !CAPNP_LITE inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; inline bool hasPathName() const; - inline ::capnp::Text::Reader getPathName() const; + inline ::capnp::Text::Reader getPathName() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; - inline ::uint32_t getCellValNum() const; + inline ::uint32_t getCellValNum() const; inline bool getOrdered() const; inline bool hasData() const; - inline ::capnp::Data::Reader getData() const; + inline ::capnp::Data::Reader getData() const; inline bool hasOffsets() const; - inline ::capnp::Data::Reader getOffsets() const; + inline ::capnp::Data::Reader getOffsets() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -3752,74 +3052,63 @@ class Enumeration::Reader { }; class Enumeration::Builder { - public: +public: typedef Enumeration Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownName(); inline bool hasPathName(); - inline ::capnp::Text::Builder getPathName(); - inline void setPathName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initPathName(unsigned int size); - inline void adoptPathName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownPathName(); + inline ::capnp::Text::Builder getPathName(); + inline void setPathName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPathName(unsigned int size); + inline void adoptPathName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPathName(); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownType(); - inline ::uint32_t getCellValNum(); - inline void setCellValNum(::uint32_t value); + inline ::uint32_t getCellValNum(); + inline void setCellValNum( ::uint32_t value); inline bool getOrdered(); inline void setOrdered(bool value); inline bool hasData(); - inline ::capnp::Data::Builder getData(); - inline void setData(::capnp::Data::Reader value); - inline ::capnp::Data::Builder initData(unsigned int size); - inline void adoptData(::capnp::Orphan<::capnp::Data>&& value); - inline ::capnp::Orphan<::capnp::Data> disownData(); + inline ::capnp::Data::Builder getData(); + inline void setData( ::capnp::Data::Reader value); + inline ::capnp::Data::Builder initData(unsigned int size); + inline void adoptData(::capnp::Orphan< ::capnp::Data>&& value); + inline ::capnp::Orphan< ::capnp::Data> disownData(); inline bool hasOffsets(); - inline ::capnp::Data::Builder getOffsets(); - inline void setOffsets(::capnp::Data::Reader value); - inline ::capnp::Data::Builder initOffsets(unsigned int size); - inline void adoptOffsets(::capnp::Orphan<::capnp::Data>&& value); - inline ::capnp::Orphan<::capnp::Data> disownOffsets(); + inline ::capnp::Data::Builder getOffsets(); + inline void setOffsets( ::capnp::Data::Reader value); + inline ::capnp::Data::Builder initOffsets(unsigned int size); + inline void adoptOffsets(::capnp::Orphan< ::capnp::Data>&& value); + inline ::capnp::Orphan< ::capnp::Data> disownOffsets(); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -3830,17 +3119,14 @@ class Enumeration::Builder { #if !CAPNP_LITE class Enumeration::Pipeline { - public: +public: typedef Enumeration Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -3849,13 +3135,11 @@ class Enumeration::Pipeline { #endif // !CAPNP_LITE class AttributeBufferHeader::Reader { - public: +public: typedef AttributeBufferHeader Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -3868,21 +3152,21 @@ class AttributeBufferHeader::Reader { #endif // !CAPNP_LITE inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; - inline ::uint64_t getFixedLenBufferSizeInBytes() const; + inline ::uint64_t getFixedLenBufferSizeInBytes() const; - inline ::uint64_t getVarLenBufferSizeInBytes() const; + inline ::uint64_t getVarLenBufferSizeInBytes() const; - inline ::uint64_t getValidityLenBufferSizeInBytes() const; + inline ::uint64_t getValidityLenBufferSizeInBytes() const; - inline ::uint64_t getOriginalFixedLenBufferSizeInBytes() const; + inline ::uint64_t getOriginalFixedLenBufferSizeInBytes() const; - inline ::uint64_t getOriginalVarLenBufferSizeInBytes() const; + inline ::uint64_t getOriginalVarLenBufferSizeInBytes() const; - inline ::uint64_t getOriginalValidityLenBufferSizeInBytes() const; + inline ::uint64_t getOriginalValidityLenBufferSizeInBytes() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -3895,58 +3179,47 @@ class AttributeBufferHeader::Reader { }; class AttributeBufferHeader::Builder { - public: +public: typedef AttributeBufferHeader Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownName(); - inline ::uint64_t getFixedLenBufferSizeInBytes(); - inline void setFixedLenBufferSizeInBytes(::uint64_t value); + inline ::uint64_t getFixedLenBufferSizeInBytes(); + inline void setFixedLenBufferSizeInBytes( ::uint64_t value); - inline ::uint64_t getVarLenBufferSizeInBytes(); - inline void setVarLenBufferSizeInBytes(::uint64_t value); + inline ::uint64_t getVarLenBufferSizeInBytes(); + inline void setVarLenBufferSizeInBytes( ::uint64_t value); - inline ::uint64_t getValidityLenBufferSizeInBytes(); - inline void setValidityLenBufferSizeInBytes(::uint64_t value); + inline ::uint64_t getValidityLenBufferSizeInBytes(); + inline void setValidityLenBufferSizeInBytes( ::uint64_t value); - inline ::uint64_t getOriginalFixedLenBufferSizeInBytes(); - inline void setOriginalFixedLenBufferSizeInBytes(::uint64_t value); + inline ::uint64_t getOriginalFixedLenBufferSizeInBytes(); + inline void setOriginalFixedLenBufferSizeInBytes( ::uint64_t value); - inline ::uint64_t getOriginalVarLenBufferSizeInBytes(); - inline void setOriginalVarLenBufferSizeInBytes(::uint64_t value); + inline ::uint64_t getOriginalVarLenBufferSizeInBytes(); + inline void setOriginalVarLenBufferSizeInBytes( ::uint64_t value); - inline ::uint64_t getOriginalValidityLenBufferSizeInBytes(); - inline void setOriginalValidityLenBufferSizeInBytes(::uint64_t value); + inline ::uint64_t getOriginalValidityLenBufferSizeInBytes(); + inline void setOriginalValidityLenBufferSizeInBytes( ::uint64_t value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -3957,17 +3230,14 @@ class AttributeBufferHeader::Builder { #if !CAPNP_LITE class AttributeBufferHeader::Pipeline { - public: +public: typedef AttributeBufferHeader Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -3976,13 +3246,11 @@ class AttributeBufferHeader::Pipeline { #endif // !CAPNP_LITE class Dimension::Reader { - public: +public: typedef Dimension Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -3995,24 +3263,22 @@ class Dimension::Reader { #endif // !CAPNP_LITE inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; inline bool getNullTileExtent() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; inline typename TileExtent::Reader getTileExtent() const; inline bool hasDomain() const; - inline ::tiledb::sm::serialization::capnp::DomainArray::Reader getDomain() - const; + inline ::tiledb::sm::serialization::capnp::DomainArray::Reader getDomain() const; inline bool hasFilterPipeline() const; - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader - getFilterPipeline() const; + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader getFilterPipeline() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4025,76 +3291,56 @@ class Dimension::Reader { }; class Dimension::Builder { - public: +public: typedef Dimension Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownName(); inline bool getNullTileExtent(); inline void setNullTileExtent(bool value); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownType(); inline typename TileExtent::Builder getTileExtent(); inline typename TileExtent::Builder initTileExtent(); inline bool hasDomain(); - inline ::tiledb::sm::serialization::capnp::DomainArray::Builder getDomain(); - inline void setDomain( - ::tiledb::sm::serialization::capnp::DomainArray::Reader value); - inline ::tiledb::sm::serialization::capnp::DomainArray::Builder initDomain(); - inline void adoptDomain( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray> - disownDomain(); + inline ::tiledb::sm::serialization::capnp::DomainArray::Builder getDomain(); + inline void setDomain( ::tiledb::sm::serialization::capnp::DomainArray::Reader value); + inline ::tiledb::sm::serialization::capnp::DomainArray::Builder initDomain(); + inline void adoptDomain(::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray> disownDomain(); inline bool hasFilterPipeline(); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder - getFilterPipeline(); - inline void setFilterPipeline( - ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder - initFilterPipeline(); - inline void adoptFilterPipeline( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> - disownFilterPipeline(); - - private: + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder getFilterPipeline(); + inline void setFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder initFilterPipeline(); + inline void adoptFilterPipeline(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> disownFilterPipeline(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -4105,22 +3351,17 @@ class Dimension::Builder { #if !CAPNP_LITE class Dimension::Pipeline { - public: +public: typedef Dimension Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} inline typename TileExtent::Pipeline getTileExtent(); - inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline getDomain(); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline - getFilterPipeline(); - - private: + inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline getDomain(); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline getFilterPipeline(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4129,13 +3370,11 @@ class Dimension::Pipeline { #endif // !CAPNP_LITE class Dimension::TileExtent::Reader { - public: +public: typedef TileExtent Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4149,28 +3388,28 @@ class Dimension::TileExtent::Reader { inline Which which() const; inline bool isInt8() const; - inline ::int8_t getInt8() const; + inline ::int8_t getInt8() const; inline bool isUint8() const; - inline ::uint8_t getUint8() const; + inline ::uint8_t getUint8() const; inline bool isInt16() const; - inline ::int16_t getInt16() const; + inline ::int16_t getInt16() const; inline bool isUint16() const; - inline ::uint16_t getUint16() const; + inline ::uint16_t getUint16() const; inline bool isInt32() const; - inline ::int32_t getInt32() const; + inline ::int32_t getInt32() const; inline bool isUint32() const; - inline ::uint32_t getUint32() const; + inline ::uint32_t getUint32() const; inline bool isInt64() const; - inline ::int64_t getInt64() const; + inline ::int64_t getInt64() const; inline bool isUint64() const; - inline ::uint64_t getUint64() const; + inline ::uint64_t getUint64() const; inline bool isFloat32() const; inline float getFloat32() const; @@ -4178,7 +3417,7 @@ class Dimension::TileExtent::Reader { inline bool isFloat64() const; inline double getFloat64() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4191,64 +3430,53 @@ class Dimension::TileExtent::Reader { }; class Dimension::TileExtent::Builder { - public: +public: typedef TileExtent Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline Which which(); inline bool isInt8(); - inline ::int8_t getInt8(); - inline void setInt8(::int8_t value); + inline ::int8_t getInt8(); + inline void setInt8( ::int8_t value); inline bool isUint8(); - inline ::uint8_t getUint8(); - inline void setUint8(::uint8_t value); + inline ::uint8_t getUint8(); + inline void setUint8( ::uint8_t value); inline bool isInt16(); - inline ::int16_t getInt16(); - inline void setInt16(::int16_t value); + inline ::int16_t getInt16(); + inline void setInt16( ::int16_t value); inline bool isUint16(); - inline ::uint16_t getUint16(); - inline void setUint16(::uint16_t value); + inline ::uint16_t getUint16(); + inline void setUint16( ::uint16_t value); inline bool isInt32(); - inline ::int32_t getInt32(); - inline void setInt32(::int32_t value); + inline ::int32_t getInt32(); + inline void setInt32( ::int32_t value); inline bool isUint32(); - inline ::uint32_t getUint32(); - inline void setUint32(::uint32_t value); + inline ::uint32_t getUint32(); + inline void setUint32( ::uint32_t value); inline bool isInt64(); - inline ::int64_t getInt64(); - inline void setInt64(::int64_t value); + inline ::int64_t getInt64(); + inline void setInt64( ::int64_t value); inline bool isUint64(); - inline ::uint64_t getUint64(); - inline void setUint64(::uint64_t value); + inline ::uint64_t getUint64(); + inline void setUint64( ::uint64_t value); inline bool isFloat32(); inline float getFloat32(); @@ -4258,7 +3486,7 @@ class Dimension::TileExtent::Builder { inline double getFloat64(); inline void setFloat64(double value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -4269,17 +3497,14 @@ class Dimension::TileExtent::Builder { #if !CAPNP_LITE class Dimension::TileExtent::Pipeline { - public: +public: typedef TileExtent Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4288,13 +3513,11 @@ class Dimension::TileExtent::Pipeline { #endif // !CAPNP_LITE class Domain::Reader { - public: +public: typedef Domain Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4307,21 +3530,18 @@ class Domain::Reader { #endif // !CAPNP_LITE inline bool hasCellOrder() const; - inline ::capnp::Text::Reader getCellOrder() const; + inline ::capnp::Text::Reader getCellOrder() const; inline bool hasDimensions() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>::Reader - getDimensions() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>::Reader getDimensions() const; inline bool hasTileOrder() const; - inline ::capnp::Text::Reader getTileOrder() const; + inline ::capnp::Text::Reader getTileOrder() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4334,74 +3554,50 @@ class Domain::Reader { }; class Domain::Builder { - public: +public: typedef Domain Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasCellOrder(); - inline ::capnp::Text::Builder getCellOrder(); - inline void setCellOrder(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initCellOrder(unsigned int size); - inline void adoptCellOrder(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownCellOrder(); + inline ::capnp::Text::Builder getCellOrder(); + inline void setCellOrder( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initCellOrder(unsigned int size); + inline void adoptCellOrder(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownCellOrder(); inline bool hasDimensions(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>::Builder - getDimensions(); - inline void setDimensions(::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>::Builder - initDimensions(unsigned int size); - inline void adoptDimensions(::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>> - disownDimensions(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>::Builder getDimensions(); + inline void setDimensions( ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>::Builder initDimensions(unsigned int size); + inline void adoptDimensions(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>> disownDimensions(); inline bool hasTileOrder(); - inline ::capnp::Text::Builder getTileOrder(); - inline void setTileOrder(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initTileOrder(unsigned int size); - inline void adoptTileOrder(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownTileOrder(); + inline ::capnp::Text::Builder getTileOrder(); + inline void setTileOrder( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initTileOrder(unsigned int size); + inline void adoptTileOrder(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownTileOrder(); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownType(); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -4412,17 +3608,14 @@ class Domain::Builder { #if !CAPNP_LITE class Domain::Pipeline { - public: +public: typedef Domain Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4431,13 +3624,11 @@ class Domain::Pipeline { #endif // !CAPNP_LITE class Error::Reader { - public: +public: typedef Error Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4449,12 +3640,12 @@ class Error::Reader { } #endif // !CAPNP_LITE - inline ::int64_t getCode() const; + inline ::int64_t getCode() const; inline bool hasMessage() const; - inline ::capnp::Text::Reader getMessage() const; + inline ::capnp::Text::Reader getMessage() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4467,43 +3658,32 @@ class Error::Reader { }; class Error::Builder { - public: +public: typedef Error Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE - inline ::int64_t getCode(); - inline void setCode(::int64_t value); + inline ::int64_t getCode(); + inline void setCode( ::int64_t value); inline bool hasMessage(); - inline ::capnp::Text::Builder getMessage(); - inline void setMessage(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initMessage(unsigned int size); - inline void adoptMessage(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownMessage(); + inline ::capnp::Text::Builder getMessage(); + inline void setMessage( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initMessage(unsigned int size); + inline void adoptMessage(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownMessage(); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -4514,17 +3694,14 @@ class Error::Builder { #if !CAPNP_LITE class Error::Pipeline { - public: +public: typedef Error Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4533,13 +3710,11 @@ class Error::Pipeline { #endif // !CAPNP_LITE class FloatScaleConfig::Reader { - public: +public: typedef FloatScaleConfig Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4555,9 +3730,9 @@ class FloatScaleConfig::Reader { inline double getOffset() const; - inline ::uint64_t getByteWidth() const; + inline ::uint64_t getByteWidth() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4570,30 +3745,19 @@ class FloatScaleConfig::Reader { }; class FloatScaleConfig::Builder { - public: +public: typedef FloatScaleConfig Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline double getScale(); @@ -4602,10 +3766,10 @@ class FloatScaleConfig::Builder { inline double getOffset(); inline void setOffset(double value); - inline ::uint64_t getByteWidth(); - inline void setByteWidth(::uint64_t value); + inline ::uint64_t getByteWidth(); + inline void setByteWidth( ::uint64_t value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -4616,17 +3780,14 @@ class FloatScaleConfig::Builder { #if !CAPNP_LITE class FloatScaleConfig::Pipeline { - public: +public: typedef FloatScaleConfig Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4635,13 +3796,11 @@ class FloatScaleConfig::Pipeline { #endif // !CAPNP_LITE class WebpConfig::Reader { - public: +public: typedef WebpConfig Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4655,15 +3814,15 @@ class WebpConfig::Reader { inline float getQuality() const; - inline ::uint8_t getFormat() const; + inline ::uint8_t getFormat() const; inline bool getLossless() const; - inline ::uint16_t getExtentX() const; + inline ::uint16_t getExtentX() const; - inline ::uint16_t getExtentY() const; + inline ::uint16_t getExtentY() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4676,48 +3835,37 @@ class WebpConfig::Reader { }; class WebpConfig::Builder { - public: +public: typedef WebpConfig Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline float getQuality(); inline void setQuality(float value); - inline ::uint8_t getFormat(); - inline void setFormat(::uint8_t value); + inline ::uint8_t getFormat(); + inline void setFormat( ::uint8_t value); inline bool getLossless(); inline void setLossless(bool value); - inline ::uint16_t getExtentX(); - inline void setExtentX(::uint16_t value); + inline ::uint16_t getExtentX(); + inline void setExtentX( ::uint16_t value); - inline ::uint16_t getExtentY(); - inline void setExtentY(::uint16_t value); + inline ::uint16_t getExtentY(); + inline void setExtentY( ::uint16_t value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -4728,17 +3876,14 @@ class WebpConfig::Builder { #if !CAPNP_LITE class WebpConfig::Pipeline { - public: +public: typedef WebpConfig Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4747,13 +3892,11 @@ class WebpConfig::Pipeline { #endif // !CAPNP_LITE class Filter::Reader { - public: +public: typedef Filter Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4766,19 +3909,17 @@ class Filter::Reader { #endif // !CAPNP_LITE inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; inline typename Data::Reader getData() const; inline bool hasFloatScaleConfig() const; - inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Reader - getFloatScaleConfig() const; + inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Reader getFloatScaleConfig() const; inline bool hasWebpConfig() const; - inline ::tiledb::sm::serialization::capnp::WebpConfig::Reader getWebpConfig() - const; + inline ::tiledb::sm::serialization::capnp::WebpConfig::Reader getWebpConfig() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4791,68 +3932,46 @@ class Filter::Reader { }; class Filter::Builder { - public: +public: typedef Filter Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownType(); inline typename Data::Builder getData(); inline typename Data::Builder initData(); inline bool hasFloatScaleConfig(); - inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Builder - getFloatScaleConfig(); - inline void setFloatScaleConfig( - ::tiledb::sm::serialization::capnp::FloatScaleConfig::Reader value); - inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Builder - initFloatScaleConfig(); - inline void adoptFloatScaleConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FloatScaleConfig>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FloatScaleConfig> - disownFloatScaleConfig(); + inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Builder getFloatScaleConfig(); + inline void setFloatScaleConfig( ::tiledb::sm::serialization::capnp::FloatScaleConfig::Reader value); + inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Builder initFloatScaleConfig(); + inline void adoptFloatScaleConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FloatScaleConfig>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FloatScaleConfig> disownFloatScaleConfig(); inline bool hasWebpConfig(); - inline ::tiledb::sm::serialization::capnp::WebpConfig::Builder - getWebpConfig(); - inline void setWebpConfig( - ::tiledb::sm::serialization::capnp::WebpConfig::Reader value); - inline ::tiledb::sm::serialization::capnp::WebpConfig::Builder - initWebpConfig(); - inline void adoptWebpConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::WebpConfig>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::WebpConfig> - disownWebpConfig(); - - private: + inline ::tiledb::sm::serialization::capnp::WebpConfig::Builder getWebpConfig(); + inline void setWebpConfig( ::tiledb::sm::serialization::capnp::WebpConfig::Reader value); + inline ::tiledb::sm::serialization::capnp::WebpConfig::Builder initWebpConfig(); + inline void adoptWebpConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::WebpConfig>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::WebpConfig> disownWebpConfig(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -4863,23 +3982,17 @@ class Filter::Builder { #if !CAPNP_LITE class Filter::Pipeline { - public: +public: typedef Filter Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} inline typename Data::Pipeline getData(); - inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Pipeline - getFloatScaleConfig(); - inline ::tiledb::sm::serialization::capnp::WebpConfig::Pipeline - getWebpConfig(); - - private: + inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Pipeline getFloatScaleConfig(); + inline ::tiledb::sm::serialization::capnp::WebpConfig::Pipeline getWebpConfig(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4888,13 +4001,11 @@ class Filter::Pipeline { #endif // !CAPNP_LITE class Filter::Data::Reader { - public: +public: typedef Data Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4909,35 +4020,35 @@ class Filter::Data::Reader { inline Which which() const; inline bool isText() const; inline bool hasText() const; - inline ::capnp::Text::Reader getText() const; + inline ::capnp::Text::Reader getText() const; inline bool isBytes() const; inline bool hasBytes() const; - inline ::capnp::Data::Reader getBytes() const; + inline ::capnp::Data::Reader getBytes() const; inline bool isInt8() const; - inline ::int8_t getInt8() const; + inline ::int8_t getInt8() const; inline bool isUint8() const; - inline ::uint8_t getUint8() const; + inline ::uint8_t getUint8() const; inline bool isInt16() const; - inline ::int16_t getInt16() const; + inline ::int16_t getInt16() const; inline bool isUint16() const; - inline ::uint16_t getUint16() const; + inline ::uint16_t getUint16() const; inline bool isInt32() const; - inline ::int32_t getInt32() const; + inline ::int32_t getInt32() const; inline bool isUint32() const; - inline ::uint32_t getUint32() const; + inline ::uint32_t getUint32() const; inline bool isInt64() const; - inline ::int64_t getInt64() const; + inline ::int64_t getInt64() const; inline bool isUint64() const; - inline ::uint64_t getUint64() const; + inline ::uint64_t getUint64() const; inline bool isFloat32() const; inline float getFloat32() const; @@ -4945,7 +4056,7 @@ class Filter::Data::Reader { inline bool isFloat64() const; inline double getFloat64() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4958,80 +4069,69 @@ class Filter::Data::Reader { }; class Filter::Data::Builder { - public: +public: typedef Data Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline Which which(); inline bool isText(); inline bool hasText(); - inline ::capnp::Text::Builder getText(); - inline void setText(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initText(unsigned int size); - inline void adoptText(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownText(); + inline ::capnp::Text::Builder getText(); + inline void setText( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initText(unsigned int size); + inline void adoptText(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownText(); inline bool isBytes(); inline bool hasBytes(); - inline ::capnp::Data::Builder getBytes(); - inline void setBytes(::capnp::Data::Reader value); - inline ::capnp::Data::Builder initBytes(unsigned int size); - inline void adoptBytes(::capnp::Orphan<::capnp::Data>&& value); - inline ::capnp::Orphan<::capnp::Data> disownBytes(); + inline ::capnp::Data::Builder getBytes(); + inline void setBytes( ::capnp::Data::Reader value); + inline ::capnp::Data::Builder initBytes(unsigned int size); + inline void adoptBytes(::capnp::Orphan< ::capnp::Data>&& value); + inline ::capnp::Orphan< ::capnp::Data> disownBytes(); inline bool isInt8(); - inline ::int8_t getInt8(); - inline void setInt8(::int8_t value); + inline ::int8_t getInt8(); + inline void setInt8( ::int8_t value); inline bool isUint8(); - inline ::uint8_t getUint8(); - inline void setUint8(::uint8_t value); + inline ::uint8_t getUint8(); + inline void setUint8( ::uint8_t value); inline bool isInt16(); - inline ::int16_t getInt16(); - inline void setInt16(::int16_t value); + inline ::int16_t getInt16(); + inline void setInt16( ::int16_t value); inline bool isUint16(); - inline ::uint16_t getUint16(); - inline void setUint16(::uint16_t value); + inline ::uint16_t getUint16(); + inline void setUint16( ::uint16_t value); inline bool isInt32(); - inline ::int32_t getInt32(); - inline void setInt32(::int32_t value); + inline ::int32_t getInt32(); + inline void setInt32( ::int32_t value); inline bool isUint32(); - inline ::uint32_t getUint32(); - inline void setUint32(::uint32_t value); + inline ::uint32_t getUint32(); + inline void setUint32( ::uint32_t value); inline bool isInt64(); - inline ::int64_t getInt64(); - inline void setInt64(::int64_t value); + inline ::int64_t getInt64(); + inline void setInt64( ::int64_t value); inline bool isUint64(); - inline ::uint64_t getUint64(); - inline void setUint64(::uint64_t value); + inline ::uint64_t getUint64(); + inline void setUint64( ::uint64_t value); inline bool isFloat32(); inline float getFloat32(); @@ -5041,7 +4141,7 @@ class Filter::Data::Builder { inline double getFloat64(); inline void setFloat64(double value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5052,17 +4152,14 @@ class Filter::Data::Builder { #if !CAPNP_LITE class Filter::Data::Pipeline { - public: +public: typedef Data Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5071,13 +4168,11 @@ class Filter::Data::Pipeline { #endif // !CAPNP_LITE class FilterPipeline::Reader { - public: +public: typedef FilterPipeline Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -5090,12 +4185,9 @@ class FilterPipeline::Reader { #endif // !CAPNP_LITE inline bool hasFilters() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>::Reader - getFilters() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>::Reader getFilters() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -5108,53 +4200,29 @@ class FilterPipeline::Reader { }; class FilterPipeline::Builder { - public: +public: typedef FilterPipeline Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasFilters(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>::Builder - getFilters(); - inline void setFilters(::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>::Builder - initFilters(unsigned int size); - inline void adoptFilters(::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>> - disownFilters(); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>::Builder getFilters(); + inline void setFilters( ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>::Builder initFilters(unsigned int size); + inline void adoptFilters(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>> disownFilters(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5165,17 +4233,14 @@ class FilterPipeline::Builder { #if !CAPNP_LITE class FilterPipeline::Pipeline { - public: +public: typedef FilterPipeline Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5185,13 +4250,11 @@ class FilterPipeline::Pipeline { template class Map::Reader { - public: +public: typedef Map Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -5203,20 +4266,15 @@ class Map::Reader { } #endif // !CAPNP_LITE - template < - typename Key2 = ::capnp::AnyPointer, - typename Value2 = ::capnp::AnyPointer> + template typename Map::Reader asGeneric() { return typename Map::Reader(_reader); } inline bool hasEntries() const; - inline typename ::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>::Reader - getEntries() const; + inline typename ::capnp::List::Entry, ::capnp::Kind::STRUCT>::Reader getEntries() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -5230,62 +4288,34 @@ class Map::Reader { template class Map::Builder { - public: +public: typedef Map Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE - template < - typename Key2 = ::capnp::AnyPointer, - typename Value2 = ::capnp::AnyPointer> + template typename Map::Builder asGeneric() { return typename Map::Builder(_builder); } inline bool hasEntries(); - inline typename ::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>::Builder - getEntries(); - inline void setEntries( - typename ::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>::Reader value); - inline typename ::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>::Builder - initEntries(unsigned int size); - inline void adoptEntries( - ::capnp::Orphan<::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>> - disownEntries(); - - private: + inline typename ::capnp::List::Entry, ::capnp::Kind::STRUCT>::Builder getEntries(); + inline void setEntries(typename ::capnp::List::Entry, ::capnp::Kind::STRUCT>::Reader value); + inline typename ::capnp::List::Entry, ::capnp::Kind::STRUCT>::Builder initEntries(unsigned int size); + inline void adoptEntries(::capnp::Orphan< ::capnp::List::Entry, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List::Entry, ::capnp::Kind::STRUCT>> disownEntries(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5297,17 +4327,14 @@ class Map::Builder { #if !CAPNP_LITE template class Map::Pipeline { - public: +public: typedef Map Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5317,13 +4344,11 @@ class Map::Pipeline { template class Map::Entry::Reader { - public: +public: typedef Entry Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -5335,20 +4360,18 @@ class Map::Entry::Reader { } #endif // !CAPNP_LITE - template < - typename Key2 = ::capnp::AnyPointer, - typename Value2 = ::capnp::AnyPointer> + template typename Map::Entry::Reader asMapGeneric() { return typename Map::Entry::Reader(_reader); } inline bool hasKey() const; - inline ::capnp::ReaderFor getKey() const; + inline ::capnp::ReaderFor getKey() const; inline bool hasValue() const; - inline ::capnp::ReaderFor getValue() const; + inline ::capnp::ReaderFor getValue() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -5362,56 +4385,43 @@ class Map::Entry::Reader { template class Map::Entry::Builder { - public: +public: typedef Entry Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE - template < - typename Key2 = ::capnp::AnyPointer, - typename Value2 = ::capnp::AnyPointer> + template typename Map::Entry::Builder asMapGeneric() { return typename Map::Entry::Builder(_builder); } inline bool hasKey(); - inline ::capnp::BuilderFor getKey(); - inline void setKey(::capnp::ReaderFor value); - inline ::capnp::BuilderFor initKey(); - inline ::capnp::BuilderFor initKey(unsigned int size); + inline ::capnp::BuilderFor getKey(); + inline void setKey( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initKey(); + inline ::capnp::BuilderFor initKey(unsigned int size); inline void adoptKey(::capnp::Orphan&& value); inline ::capnp::Orphan disownKey(); inline bool hasValue(); - inline ::capnp::BuilderFor getValue(); - inline void setValue(::capnp::ReaderFor value); - inline ::capnp::BuilderFor initValue(); - inline ::capnp::BuilderFor initValue(unsigned int size); + inline ::capnp::BuilderFor getValue(); + inline void setValue( ::capnp::ReaderFor value); + inline ::capnp::BuilderFor initValue(); + inline ::capnp::BuilderFor initValue(unsigned int size); inline void adoptValue(::capnp::Orphan&& value); inline ::capnp::Orphan disownValue(); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5423,20 +4433,16 @@ class Map::Entry::Builder { #if !CAPNP_LITE template class Map::Entry::Pipeline { - public: +public: typedef Entry Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::capnp::PipelineFor getKey(); - inline ::capnp::PipelineFor getValue(); - - private: + inline ::capnp::PipelineFor getKey(); + inline ::capnp::PipelineFor getValue(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5445,13 +4451,11 @@ class Map::Entry::Pipeline { #endif // !CAPNP_LITE class MapEnumeration::Reader { - public: +public: typedef MapEnumeration Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -5464,12 +4468,9 @@ class MapEnumeration::Reader { #endif // !CAPNP_LITE inline bool hasEntries() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>::Reader - getEntries() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>::Reader getEntries() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -5482,55 +4483,29 @@ class MapEnumeration::Reader { }; class MapEnumeration::Builder { - public: +public: typedef MapEnumeration Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasEntries(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>::Builder - getEntries(); - inline void setEntries( - ::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>::Builder - initEntries(unsigned int size); - inline void adoptEntries( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>> - disownEntries(); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>::Builder getEntries(); + inline void setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>::Builder initEntries(unsigned int size); + inline void adoptEntries(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>> disownEntries(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5541,17 +4516,14 @@ class MapEnumeration::Builder { #if !CAPNP_LITE class MapEnumeration::Pipeline { - public: +public: typedef MapEnumeration Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5560,13 +4532,11 @@ class MapEnumeration::Pipeline { #endif // !CAPNP_LITE class MapEnumeration::Entry::Reader { - public: +public: typedef Entry Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -5579,15 +4549,12 @@ class MapEnumeration::Entry::Reader { #endif // !CAPNP_LITE inline bool hasKey() const; - inline ::capnp::Text::Reader getKey() const; + inline ::capnp::Text::Reader getKey() const; inline bool hasValue() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader - getValue() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader getValue() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -5600,60 +4567,36 @@ class MapEnumeration::Entry::Reader { }; class MapEnumeration::Entry::Builder { - public: +public: typedef Entry Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasKey(); - inline ::capnp::Text::Builder getKey(); - inline void setKey(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initKey(unsigned int size); - inline void adoptKey(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownKey(); + inline ::capnp::Text::Builder getKey(); + inline void setKey( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initKey(unsigned int size); + inline void adoptKey(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownKey(); inline bool hasValue(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder - getValue(); - inline void setValue(::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder - initValue(unsigned int size); - inline void adoptValue(::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>> - disownValue(); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder getValue(); + inline void setValue( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder initValue(unsigned int size); + inline void adoptValue(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> disownValue(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5664,17 +4607,14 @@ class MapEnumeration::Entry::Builder { #if !CAPNP_LITE class MapEnumeration::Entry::Pipeline { - public: +public: typedef Entry Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5683,13 +4623,11 @@ class MapEnumeration::Entry::Pipeline { #endif // !CAPNP_LITE class MapUInt32::Reader { - public: +public: typedef MapUInt32 Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -5702,12 +4640,9 @@ class MapUInt32::Reader { #endif // !CAPNP_LITE inline bool hasEntries() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>::Reader - getEntries() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>::Reader getEntries() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -5720,54 +4655,29 @@ class MapUInt32::Reader { }; class MapUInt32::Builder { - public: +public: typedef MapUInt32 Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasEntries(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>::Builder - getEntries(); - inline void setEntries(::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>::Builder - initEntries(unsigned int size); - inline void adoptEntries( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>> - disownEntries(); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>::Builder getEntries(); + inline void setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>::Builder initEntries(unsigned int size); + inline void adoptEntries(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>> disownEntries(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5778,17 +4688,14 @@ class MapUInt32::Builder { #if !CAPNP_LITE class MapUInt32::Pipeline { - public: +public: typedef MapUInt32 Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5797,13 +4704,11 @@ class MapUInt32::Pipeline { #endif // !CAPNP_LITE class MapUInt32::Entry::Reader { - public: +public: typedef Entry Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -5816,11 +4721,11 @@ class MapUInt32::Entry::Reader { #endif // !CAPNP_LITE inline bool hasKey() const; - inline ::capnp::Text::Reader getKey() const; + inline ::capnp::Text::Reader getKey() const; - inline ::uint32_t getValue() const; + inline ::uint32_t getValue() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -5833,43 +4738,32 @@ class MapUInt32::Entry::Reader { }; class MapUInt32::Entry::Builder { - public: +public: typedef Entry Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasKey(); - inline ::capnp::Text::Builder getKey(); - inline void setKey(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initKey(unsigned int size); - inline void adoptKey(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownKey(); + inline ::capnp::Text::Builder getKey(); + inline void setKey( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initKey(unsigned int size); + inline void adoptKey(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownKey(); - inline ::uint32_t getValue(); - inline void setValue(::uint32_t value); + inline ::uint32_t getValue(); + inline void setValue( ::uint32_t value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5880,17 +4774,14 @@ class MapUInt32::Entry::Builder { #if !CAPNP_LITE class MapUInt32::Entry::Pipeline { - public: +public: typedef Entry Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5899,13 +4790,11 @@ class MapUInt32::Entry::Pipeline { #endif // !CAPNP_LITE class MapInt64::Reader { - public: +public: typedef MapInt64 Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -5918,12 +4807,9 @@ class MapInt64::Reader { #endif // !CAPNP_LITE inline bool hasEntries() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>::Reader - getEntries() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>::Reader getEntries() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -5936,54 +4822,29 @@ class MapInt64::Reader { }; class MapInt64::Builder { - public: +public: typedef MapInt64 Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasEntries(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>::Builder - getEntries(); - inline void setEntries(::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>::Builder - initEntries(unsigned int size); - inline void adoptEntries( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>> - disownEntries(); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>::Builder getEntries(); + inline void setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>::Builder initEntries(unsigned int size); + inline void adoptEntries(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>> disownEntries(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5994,17 +4855,14 @@ class MapInt64::Builder { #if !CAPNP_LITE class MapInt64::Pipeline { - public: +public: typedef MapInt64 Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -6013,13 +4871,11 @@ class MapInt64::Pipeline { #endif // !CAPNP_LITE class MapInt64::Entry::Reader { - public: +public: typedef Entry Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -6032,11 +4888,11 @@ class MapInt64::Entry::Reader { #endif // !CAPNP_LITE inline bool hasKey() const; - inline ::capnp::Text::Reader getKey() const; + inline ::capnp::Text::Reader getKey() const; - inline ::int64_t getValue() const; + inline ::int64_t getValue() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -6049,43 +4905,32 @@ class MapInt64::Entry::Reader { }; class MapInt64::Entry::Builder { - public: +public: typedef Entry Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasKey(); - inline ::capnp::Text::Builder getKey(); - inline void setKey(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initKey(unsigned int size); - inline void adoptKey(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownKey(); + inline ::capnp::Text::Builder getKey(); + inline void setKey( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initKey(unsigned int size); + inline void adoptKey(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownKey(); - inline ::int64_t getValue(); - inline void setValue(::int64_t value); + inline ::int64_t getValue(); + inline void setValue( ::int64_t value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -6096,17 +4941,14 @@ class MapInt64::Entry::Builder { #if !CAPNP_LITE class MapInt64::Entry::Pipeline { - public: +public: typedef Entry Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -6115,13 +4957,11 @@ class MapInt64::Entry::Pipeline { #endif // !CAPNP_LITE class MapUInt64::Reader { - public: +public: typedef MapUInt64 Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -6134,12 +4974,9 @@ class MapUInt64::Reader { #endif // !CAPNP_LITE inline bool hasEntries() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>::Reader - getEntries() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>::Reader getEntries() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -6152,54 +4989,29 @@ class MapUInt64::Reader { }; class MapUInt64::Builder { - public: +public: typedef MapUInt64 Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasEntries(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>::Builder - getEntries(); - inline void setEntries(::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>::Builder - initEntries(unsigned int size); - inline void adoptEntries( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>> - disownEntries(); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>::Builder getEntries(); + inline void setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>::Builder initEntries(unsigned int size); + inline void adoptEntries(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>> disownEntries(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -6210,17 +5022,14 @@ class MapUInt64::Builder { #if !CAPNP_LITE class MapUInt64::Pipeline { - public: +public: typedef MapUInt64 Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -6229,13 +5038,11 @@ class MapUInt64::Pipeline { #endif // !CAPNP_LITE class MapUInt64::Entry::Reader { - public: +public: typedef Entry Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -6248,11 +5055,11 @@ class MapUInt64::Entry::Reader { #endif // !CAPNP_LITE inline bool hasKey() const; - inline ::capnp::Text::Reader getKey() const; + inline ::capnp::Text::Reader getKey() const; - inline ::uint64_t getValue() const; + inline ::uint64_t getValue() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -6265,43 +5072,32 @@ class MapUInt64::Entry::Reader { }; class MapUInt64::Entry::Builder { - public: +public: typedef Entry Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasKey(); - inline ::capnp::Text::Builder getKey(); - inline void setKey(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initKey(unsigned int size); - inline void adoptKey(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownKey(); + inline ::capnp::Text::Builder getKey(); + inline void setKey( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initKey(unsigned int size); + inline void adoptKey(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownKey(); - inline ::uint64_t getValue(); - inline void setValue(::uint64_t value); + inline ::uint64_t getValue(); + inline void setValue( ::uint64_t value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -6312,17 +5108,14 @@ class MapUInt64::Entry::Builder { #if !CAPNP_LITE class MapUInt64::Entry::Pipeline { - public: +public: typedef Entry Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -6331,13 +5124,11 @@ class MapUInt64::Entry::Pipeline { #endif // !CAPNP_LITE class MapFloat64::Reader { - public: +public: typedef MapFloat64 Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -6350,12 +5141,9 @@ class MapFloat64::Reader { #endif // !CAPNP_LITE inline bool hasEntries() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>::Reader - getEntries() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>::Reader getEntries() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -6368,54 +5156,29 @@ class MapFloat64::Reader { }; class MapFloat64::Builder { - public: +public: typedef MapFloat64 Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasEntries(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>::Builder - getEntries(); - inline void setEntries(::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>::Builder - initEntries(unsigned int size); - inline void adoptEntries( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>> - disownEntries(); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>::Builder getEntries(); + inline void setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>::Builder initEntries(unsigned int size); + inline void adoptEntries(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>> disownEntries(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -6426,17 +5189,14 @@ class MapFloat64::Builder { #if !CAPNP_LITE class MapFloat64::Pipeline { - public: +public: typedef MapFloat64 Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -6445,13 +5205,11 @@ class MapFloat64::Pipeline { #endif // !CAPNP_LITE class MapFloat64::Entry::Reader { - public: +public: typedef Entry Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -6464,11 +5222,11 @@ class MapFloat64::Entry::Reader { #endif // !CAPNP_LITE inline bool hasKey() const; - inline ::capnp::Text::Reader getKey() const; + inline ::capnp::Text::Reader getKey() const; inline double getValue() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -6481,43 +5239,32 @@ class MapFloat64::Entry::Reader { }; class MapFloat64::Entry::Builder { - public: +public: typedef Entry Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasKey(); - inline ::capnp::Text::Builder getKey(); - inline void setKey(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initKey(unsigned int size); - inline void adoptKey(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownKey(); + inline ::capnp::Text::Builder getKey(); + inline void setKey( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initKey(unsigned int size); + inline void adoptKey(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownKey(); inline double getValue(); inline void setValue(double value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -6528,17 +5275,14 @@ class MapFloat64::Entry::Builder { #if !CAPNP_LITE class MapFloat64::Entry::Pipeline { - public: +public: typedef Entry Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -6547,13 +5291,11 @@ class MapFloat64::Entry::Pipeline { #endif // !CAPNP_LITE class Stats::Reader { - public: +public: typedef Stats Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -6566,14 +5308,12 @@ class Stats::Reader { #endif // !CAPNP_LITE inline bool hasTimers() const; - inline ::tiledb::sm::serialization::capnp::MapFloat64::Reader getTimers() - const; + inline ::tiledb::sm::serialization::capnp::MapFloat64::Reader getTimers() const; inline bool hasCounters() const; - inline ::tiledb::sm::serialization::capnp::MapUInt64::Reader getCounters() - const; + inline ::tiledb::sm::serialization::capnp::MapUInt64::Reader getCounters() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -6586,53 +5326,36 @@ class Stats::Reader { }; class Stats::Builder { - public: +public: typedef Stats Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasTimers(); - inline ::tiledb::sm::serialization::capnp::MapFloat64::Builder getTimers(); - inline void setTimers( - ::tiledb::sm::serialization::capnp::MapFloat64::Reader value); - inline ::tiledb::sm::serialization::capnp::MapFloat64::Builder initTimers(); - inline void adoptTimers( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapFloat64>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapFloat64> - disownTimers(); + inline ::tiledb::sm::serialization::capnp::MapFloat64::Builder getTimers(); + inline void setTimers( ::tiledb::sm::serialization::capnp::MapFloat64::Reader value); + inline ::tiledb::sm::serialization::capnp::MapFloat64::Builder initTimers(); + inline void adoptTimers(::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapFloat64>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapFloat64> disownTimers(); inline bool hasCounters(); - inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder getCounters(); - inline void setCounters( - ::tiledb::sm::serialization::capnp::MapUInt64::Reader value); - inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder initCounters(); - inline void adoptCounters( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapUInt64>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapUInt64> - disownCounters(); - - private: + inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder getCounters(); + inline void setCounters( ::tiledb::sm::serialization::capnp::MapUInt64::Reader value); + inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder initCounters(); + inline void adoptCounters(::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapUInt64>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapUInt64> disownCounters(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -6643,20 +5366,16 @@ class Stats::Builder { #if !CAPNP_LITE class Stats::Pipeline { - public: +public: typedef Stats Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::MapFloat64::Pipeline getTimers(); - inline ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline getCounters(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::MapFloat64::Pipeline getTimers(); + inline ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline getCounters(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -6665,13 +5384,11 @@ class Stats::Pipeline { #endif // !CAPNP_LITE class UnorderedWriterState::Reader { - public: +public: typedef UnorderedWriterState Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -6686,18 +5403,15 @@ class UnorderedWriterState::Reader { inline bool getIsCoordsPass() const; inline bool hasCellPos() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getCellPos() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getCellPos() const; inline bool hasCoordDups() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getCoordDups() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getCoordDups() const; inline bool hasFragMeta() const; - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader - getFragMeta() const; + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader getFragMeta() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -6710,77 +5424,48 @@ class UnorderedWriterState::Reader { }; class UnorderedWriterState::Builder { - public: +public: typedef UnorderedWriterState Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool getIsCoordsPass(); inline void setIsCoordsPass(bool value); inline bool hasCellPos(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getCellPos(); - inline void setCellPos( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setCellPos(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initCellPos(unsigned int size); - inline void adoptCellPos( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownCellPos(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getCellPos(); + inline void setCellPos( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setCellPos(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initCellPos(unsigned int size); + inline void adoptCellPos(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownCellPos(); inline bool hasCoordDups(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getCoordDups(); - inline void setCoordDups( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setCoordDups(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initCoordDups(unsigned int size); - inline void adoptCoordDups( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownCoordDups(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getCoordDups(); + inline void setCoordDups( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setCoordDups(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initCoordDups(unsigned int size); + inline void adoptCoordDups(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownCoordDups(); inline bool hasFragMeta(); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder - getFragMeta(); - inline void setFragMeta( - ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder - initFragMeta(); - inline void adoptFragMeta( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata> - disownFragMeta(); - - private: + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder getFragMeta(); + inline void setFragMeta( ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value); + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder initFragMeta(); + inline void adoptFragMeta(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata> disownFragMeta(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -6791,20 +5476,15 @@ class UnorderedWriterState::Builder { #if !CAPNP_LITE class UnorderedWriterState::Pipeline { - public: +public: typedef UnorderedWriterState Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline - getFragMeta(); - - private: + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline getFragMeta(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -6813,13 +5493,11 @@ class UnorderedWriterState::Pipeline { #endif // !CAPNP_LITE class Writer::Reader { - public: +public: typedef Writer Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -6838,25 +5516,21 @@ class Writer::Reader { inline bool getDedupCoords() const; inline bool hasSubarray() const; - inline ::tiledb::sm::serialization::capnp::DomainArray::Reader getSubarray() - const; + inline ::tiledb::sm::serialization::capnp::DomainArray::Reader getSubarray() const; inline bool hasSubarrayRanges() const; - inline ::tiledb::sm::serialization::capnp::Subarray::Reader - getSubarrayRanges() const; + inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarrayRanges() const; inline bool hasStats() const; - inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; + inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; inline bool hasGlobalWriteStateV1() const; - inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Reader - getGlobalWriteStateV1() const; + inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Reader getGlobalWriteStateV1() const; inline bool hasUnorderedWriterState() const; - inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Reader - getUnorderedWriterState() const; + inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Reader getUnorderedWriterState() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -6869,30 +5543,19 @@ class Writer::Reader { }; class Writer::Builder { - public: +public: typedef Writer Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool getCheckCoordDups(); @@ -6905,65 +5568,41 @@ class Writer::Builder { inline void setDedupCoords(bool value); inline bool hasSubarray(); - inline ::tiledb::sm::serialization::capnp::DomainArray::Builder getSubarray(); - inline void setSubarray( - ::tiledb::sm::serialization::capnp::DomainArray::Reader value); - inline ::tiledb::sm::serialization::capnp::DomainArray::Builder - initSubarray(); - inline void adoptSubarray( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray> - disownSubarray(); + inline ::tiledb::sm::serialization::capnp::DomainArray::Builder getSubarray(); + inline void setSubarray( ::tiledb::sm::serialization::capnp::DomainArray::Reader value); + inline ::tiledb::sm::serialization::capnp::DomainArray::Builder initSubarray(); + inline void adoptSubarray(::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray> disownSubarray(); inline bool hasSubarrayRanges(); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder - getSubarrayRanges(); - inline void setSubarrayRanges( - ::tiledb::sm::serialization::capnp::Subarray::Reader value); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder - initSubarrayRanges(); - inline void adoptSubarrayRanges( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> - disownSubarrayRanges(); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarrayRanges(); + inline void setSubarrayRanges( ::tiledb::sm::serialization::capnp::Subarray::Reader value); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarrayRanges(); + inline void adoptSubarrayRanges(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> disownSubarrayRanges(); inline bool hasStats(); - inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); - inline void setStats(::tiledb::sm::serialization::capnp::Stats::Reader value); - inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); - inline void adoptStats( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> - disownStats(); + inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); + inline void setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value); + inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); + inline void adoptStats(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> disownStats(); inline bool hasGlobalWriteStateV1(); - inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Builder - getGlobalWriteStateV1(); - inline void setGlobalWriteStateV1( - ::tiledb::sm::serialization::capnp::GlobalWriteState::Reader value); - inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Builder - initGlobalWriteStateV1(); - inline void adoptGlobalWriteStateV1( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::GlobalWriteState>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::GlobalWriteState> - disownGlobalWriteStateV1(); + inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Builder getGlobalWriteStateV1(); + inline void setGlobalWriteStateV1( ::tiledb::sm::serialization::capnp::GlobalWriteState::Reader value); + inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Builder initGlobalWriteStateV1(); + inline void adoptGlobalWriteStateV1(::capnp::Orphan< ::tiledb::sm::serialization::capnp::GlobalWriteState>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GlobalWriteState> disownGlobalWriteStateV1(); inline bool hasUnorderedWriterState(); - inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Builder - getUnorderedWriterState(); - inline void setUnorderedWriterState( - ::tiledb::sm::serialization::capnp::UnorderedWriterState::Reader value); - inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Builder - initUnorderedWriterState(); - inline void adoptUnorderedWriterState( - ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::UnorderedWriterState>&& value); - inline ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::UnorderedWriterState> - disownUnorderedWriterState(); - - private: + inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Builder getUnorderedWriterState(); + inline void setUnorderedWriterState( ::tiledb::sm::serialization::capnp::UnorderedWriterState::Reader value); + inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Builder initUnorderedWriterState(); + inline void adoptUnorderedWriterState(::capnp::Orphan< ::tiledb::sm::serialization::capnp::UnorderedWriterState>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::UnorderedWriterState> disownUnorderedWriterState(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -6974,27 +5613,19 @@ class Writer::Builder { #if !CAPNP_LITE class Writer::Pipeline { - public: +public: typedef Writer Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline - getSubarray(); - inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline - getSubarrayRanges(); - inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); - inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Pipeline - getGlobalWriteStateV1(); - inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Pipeline - getUnorderedWriterState(); - - private: + : _typeless(kj::mv(typeless)) {} + + inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline getSubarray(); + inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarrayRanges(); + inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); + inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Pipeline getGlobalWriteStateV1(); + inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Pipeline getUnorderedWriterState(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -7003,13 +5634,11 @@ class Writer::Pipeline { #endif // !CAPNP_LITE class SubarrayRanges::Reader { - public: +public: typedef SubarrayRanges Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -7022,22 +5651,20 @@ class SubarrayRanges::Reader { #endif // !CAPNP_LITE inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; inline bool getHasDefaultRange() const; inline bool hasBuffer() const; - inline ::capnp::Data::Reader getBuffer() const; + inline ::capnp::Data::Reader getBuffer() const; inline bool hasBufferSizes() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getBufferSizes() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getBufferSizes() const; inline bool hasBufferStartSizes() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getBufferStartSizes() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getBufferStartSizes() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -7050,78 +5677,55 @@ class SubarrayRanges::Reader { }; class SubarrayRanges::Builder { - public: +public: typedef SubarrayRanges Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownType(); inline bool getHasDefaultRange(); inline void setHasDefaultRange(bool value); inline bool hasBuffer(); - inline ::capnp::Data::Builder getBuffer(); - inline void setBuffer(::capnp::Data::Reader value); - inline ::capnp::Data::Builder initBuffer(unsigned int size); - inline void adoptBuffer(::capnp::Orphan<::capnp::Data>&& value); - inline ::capnp::Orphan<::capnp::Data> disownBuffer(); + inline ::capnp::Data::Builder getBuffer(); + inline void setBuffer( ::capnp::Data::Reader value); + inline ::capnp::Data::Builder initBuffer(unsigned int size); + inline void adoptBuffer(::capnp::Orphan< ::capnp::Data>&& value); + inline ::capnp::Orphan< ::capnp::Data> disownBuffer(); inline bool hasBufferSizes(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getBufferSizes(); - inline void setBufferSizes( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setBufferSizes(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initBufferSizes(unsigned int size); - inline void adoptBufferSizes( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownBufferSizes(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getBufferSizes(); + inline void setBufferSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setBufferSizes(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initBufferSizes(unsigned int size); + inline void adoptBufferSizes(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownBufferSizes(); inline bool hasBufferStartSizes(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getBufferStartSizes(); - inline void setBufferStartSizes( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setBufferStartSizes(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initBufferStartSizes(unsigned int size); - inline void adoptBufferStartSizes( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownBufferStartSizes(); - - private: + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getBufferStartSizes(); + inline void setBufferStartSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setBufferStartSizes(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initBufferStartSizes(unsigned int size); + inline void adoptBufferStartSizes(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownBufferStartSizes(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -7132,17 +5736,14 @@ class SubarrayRanges::Builder { #if !CAPNP_LITE class SubarrayRanges::Pipeline { - public: +public: typedef SubarrayRanges Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -7151,13 +5752,11 @@ class SubarrayRanges::Pipeline { #endif // !CAPNP_LITE class LabelSubarrayRanges::Reader { - public: +public: typedef LabelSubarrayRanges Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -7169,16 +5768,15 @@ class LabelSubarrayRanges::Reader { } #endif // !CAPNP_LITE - inline ::uint32_t getDimensionId() const; + inline ::uint32_t getDimensionId() const; inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; inline bool hasRanges() const; - inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Reader getRanges() - const; + inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Reader getRanges() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -7191,56 +5789,39 @@ class LabelSubarrayRanges::Reader { }; class LabelSubarrayRanges::Builder { - public: +public: typedef LabelSubarrayRanges Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE - inline ::uint32_t getDimensionId(); - inline void setDimensionId(::uint32_t value); + inline ::uint32_t getDimensionId(); + inline void setDimensionId( ::uint32_t value); inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownName(); inline bool hasRanges(); - inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Builder - getRanges(); - inline void setRanges( - ::tiledb::sm::serialization::capnp::SubarrayRanges::Reader value); - inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Builder - initRanges(); - inline void adoptRanges( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayRanges>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayRanges> - disownRanges(); - - private: + inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Builder getRanges(); + inline void setRanges( ::tiledb::sm::serialization::capnp::SubarrayRanges::Reader value); + inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Builder initRanges(); + inline void adoptRanges(::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayRanges>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayRanges> disownRanges(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -7251,20 +5832,15 @@ class LabelSubarrayRanges::Builder { #if !CAPNP_LITE class LabelSubarrayRanges::Pipeline { - public: +public: typedef LabelSubarrayRanges Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Pipeline - getRanges(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Pipeline getRanges(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -7273,13 +5849,11 @@ class LabelSubarrayRanges::Pipeline { #endif // !CAPNP_LITE class Subarray::Reader { - public: +public: typedef Subarray Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -7292,36 +5866,26 @@ class Subarray::Reader { #endif // !CAPNP_LITE inline bool hasLayout() const; - inline ::capnp::Text::Reader getLayout() const; + inline ::capnp::Text::Reader getLayout() const; inline bool hasRanges() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>::Reader - getRanges() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Reader getRanges() const; inline bool hasStats() const; - inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; + inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; inline bool hasRelevantFragments() const; - inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader - getRelevantFragments() const; + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader getRelevantFragments() const; inline bool hasLabelRanges() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>::Reader - getLabelRanges() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>::Reader getLabelRanges() const; inline bool hasAttributeRanges() const; - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>::Reader - getAttributeRanges() const; + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Reader getAttributeRanges() const; inline bool getCoalesceRanges() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -7334,131 +5898,68 @@ class Subarray::Reader { }; class Subarray::Builder { - public: +public: typedef Subarray Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasLayout(); - inline ::capnp::Text::Builder getLayout(); - inline void setLayout(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initLayout(unsigned int size); - inline void adoptLayout(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownLayout(); + inline ::capnp::Text::Builder getLayout(); + inline void setLayout( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initLayout(unsigned int size); + inline void adoptLayout(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownLayout(); inline bool hasRanges(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>::Builder - getRanges(); - inline void setRanges(::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>::Builder - initRanges(unsigned int size); - inline void adoptRanges( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>> - disownRanges(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Builder getRanges(); + inline void setRanges( ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Builder initRanges(unsigned int size); + inline void adoptRanges(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>> disownRanges(); inline bool hasStats(); - inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); - inline void setStats(::tiledb::sm::serialization::capnp::Stats::Reader value); - inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); - inline void adoptStats( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> - disownStats(); + inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); + inline void setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value); + inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); + inline void adoptStats(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> disownStats(); inline bool hasRelevantFragments(); - inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder - getRelevantFragments(); - inline void setRelevantFragments( - ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setRelevantFragments(::kj::ArrayPtr value); - inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder - initRelevantFragments(unsigned int size); - inline void adoptRelevantFragments( - ::capnp::Orphan<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>> - disownRelevantFragments(); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder getRelevantFragments(); + inline void setRelevantFragments( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setRelevantFragments(::kj::ArrayPtr value); + inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder initRelevantFragments(unsigned int size); + inline void adoptRelevantFragments(::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> disownRelevantFragments(); inline bool hasLabelRanges(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>::Builder - getLabelRanges(); - inline void setLabelRanges( - ::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>::Builder - initLabelRanges(unsigned int size); - inline void adoptLabelRanges( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>> - disownLabelRanges(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>::Builder getLabelRanges(); + inline void setLabelRanges( ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>::Builder initLabelRanges(unsigned int size); + inline void adoptLabelRanges(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>> disownLabelRanges(); inline bool hasAttributeRanges(); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>::Builder - getAttributeRanges(); - inline void setAttributeRanges( - ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>::Reader value); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>::Builder - initAttributeRanges(); - inline void adoptAttributeRanges( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>> - disownAttributeRanges(); + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Builder getAttributeRanges(); + inline void setAttributeRanges( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Reader value); + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Builder initAttributeRanges(); + inline void adoptAttributeRanges(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>> disownAttributeRanges(); inline bool getCoalesceRanges(); inline void setCoalesceRanges(bool value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -7469,23 +5970,16 @@ class Subarray::Builder { #if !CAPNP_LITE class Subarray::Pipeline { - public: +public: typedef Subarray Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>::Pipeline - getAttributeRanges(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Pipeline getAttributeRanges(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -7494,13 +5988,11 @@ class Subarray::Pipeline { #endif // !CAPNP_LITE class SubarrayPartitioner::Reader { - public: +public: typedef SubarrayPartitioner Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -7513,34 +6005,27 @@ class SubarrayPartitioner::Reader { #endif // !CAPNP_LITE inline bool hasSubarray() const; - inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarray() - const; + inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarray() const; inline bool hasBudget() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>::Reader - getBudget() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>::Reader getBudget() const; inline bool hasCurrent() const; - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner:: - PartitionInfo::Reader - getCurrent() const; + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Reader getCurrent() const; inline bool hasState() const; - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Reader - getState() const; + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Reader getState() const; - inline ::uint64_t getMemoryBudget() const; + inline ::uint64_t getMemoryBudget() const; - inline ::uint64_t getMemoryBudgetVar() const; + inline ::uint64_t getMemoryBudgetVar() const; - inline ::uint64_t getMemoryBudgetValidity() const; + inline ::uint64_t getMemoryBudgetValidity() const; inline bool hasStats() const; - inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; + inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -7553,114 +6038,66 @@ class SubarrayPartitioner::Reader { }; class SubarrayPartitioner::Builder { - public: +public: typedef SubarrayPartitioner Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasSubarray(); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarray(); - inline void setSubarray( - ::tiledb::sm::serialization::capnp::Subarray::Reader value); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarray(); - inline void adoptSubarray( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> - disownSubarray(); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarray(); + inline void setSubarray( ::tiledb::sm::serialization::capnp::Subarray::Reader value); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarray(); + inline void adoptSubarray(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> disownSubarray(); inline bool hasBudget(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>::Builder - getBudget(); - inline void setBudget(::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>::Builder - initBudget(unsigned int size); - inline void adoptBudget( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>> - disownBudget(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>::Builder getBudget(); + inline void setBudget( ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>::Builder initBudget(unsigned int size); + inline void adoptBudget(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>> disownBudget(); inline bool hasCurrent(); - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner:: - PartitionInfo::Builder - getCurrent(); - inline void setCurrent(::tiledb::sm::serialization::capnp:: - SubarrayPartitioner::PartitionInfo::Reader value); - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner:: - PartitionInfo::Builder - initCurrent(); - inline void adoptCurrent( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayPartitioner:: - PartitionInfo>&& value); - inline ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo> - disownCurrent(); + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Builder getCurrent(); + inline void setCurrent( ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Reader value); + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Builder initCurrent(); + inline void adoptCurrent(::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo> disownCurrent(); inline bool hasState(); - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Builder - getState(); - inline void setState( - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Reader - value); - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Builder - initState(); - inline void adoptState( - ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>&& - value); - inline ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State> - disownState(); - - inline ::uint64_t getMemoryBudget(); - inline void setMemoryBudget(::uint64_t value); - - inline ::uint64_t getMemoryBudgetVar(); - inline void setMemoryBudgetVar(::uint64_t value); - - inline ::uint64_t getMemoryBudgetValidity(); - inline void setMemoryBudgetValidity(::uint64_t value); + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Builder getState(); + inline void setState( ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Reader value); + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Builder initState(); + inline void adoptState(::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State> disownState(); + + inline ::uint64_t getMemoryBudget(); + inline void setMemoryBudget( ::uint64_t value); + + inline ::uint64_t getMemoryBudgetVar(); + inline void setMemoryBudgetVar( ::uint64_t value); + + inline ::uint64_t getMemoryBudgetValidity(); + inline void setMemoryBudgetValidity( ::uint64_t value); inline bool hasStats(); - inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); - inline void setStats(::tiledb::sm::serialization::capnp::Stats::Reader value); - inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); - inline void adoptStats( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> - disownStats(); - - private: + inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); + inline void setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value); + inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); + inline void adoptStats(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> disownStats(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -7671,26 +6108,18 @@ class SubarrayPartitioner::Builder { #if !CAPNP_LITE class SubarrayPartitioner::Pipeline { - public: +public: typedef SubarrayPartitioner Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarray(); - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner:: - PartitionInfo::Pipeline - getCurrent(); - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State:: - Pipeline - getState(); - inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarray(); + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Pipeline getCurrent(); + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Pipeline getState(); + inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -7699,13 +6128,11 @@ class SubarrayPartitioner::Pipeline { #endif // !CAPNP_LITE class SubarrayPartitioner::PartitionInfo::Reader { - public: +public: typedef PartitionInfo Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -7718,16 +6145,15 @@ class SubarrayPartitioner::PartitionInfo::Reader { #endif // !CAPNP_LITE inline bool hasSubarray() const; - inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarray() - const; + inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarray() const; - inline ::uint64_t getStart() const; + inline ::uint64_t getStart() const; - inline ::uint64_t getEnd() const; + inline ::uint64_t getEnd() const; inline bool getSplitMultiRange() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -7740,52 +6166,38 @@ class SubarrayPartitioner::PartitionInfo::Reader { }; class SubarrayPartitioner::PartitionInfo::Builder { - public: +public: typedef PartitionInfo Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasSubarray(); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarray(); - inline void setSubarray( - ::tiledb::sm::serialization::capnp::Subarray::Reader value); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarray(); - inline void adoptSubarray( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> - disownSubarray(); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarray(); + inline void setSubarray( ::tiledb::sm::serialization::capnp::Subarray::Reader value); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarray(); + inline void adoptSubarray(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> disownSubarray(); - inline ::uint64_t getStart(); - inline void setStart(::uint64_t value); + inline ::uint64_t getStart(); + inline void setStart( ::uint64_t value); - inline ::uint64_t getEnd(); - inline void setEnd(::uint64_t value); + inline ::uint64_t getEnd(); + inline void setEnd( ::uint64_t value); inline bool getSplitMultiRange(); inline void setSplitMultiRange(bool value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -7796,19 +6208,15 @@ class SubarrayPartitioner::PartitionInfo::Builder { #if !CAPNP_LITE class SubarrayPartitioner::PartitionInfo::Pipeline { - public: +public: typedef PartitionInfo Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarray(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarray(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -7817,13 +6225,11 @@ class SubarrayPartitioner::PartitionInfo::Pipeline { #endif // !CAPNP_LITE class SubarrayPartitioner::State::Reader { - public: +public: typedef State Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -7835,23 +6241,17 @@ class SubarrayPartitioner::State::Reader { } #endif // !CAPNP_LITE - inline ::uint64_t getStart() const; + inline ::uint64_t getStart() const; - inline ::uint64_t getEnd() const; + inline ::uint64_t getEnd() const; inline bool hasSingleRange() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>::Reader - getSingleRange() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Reader getSingleRange() const; inline bool hasMultiRange() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>::Reader - getMultiRange() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Reader getMultiRange() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -7864,79 +6264,42 @@ class SubarrayPartitioner::State::Reader { }; class SubarrayPartitioner::State::Builder { - public: +public: typedef State Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE - inline ::uint64_t getStart(); - inline void setStart(::uint64_t value); + inline ::uint64_t getStart(); + inline void setStart( ::uint64_t value); - inline ::uint64_t getEnd(); - inline void setEnd(::uint64_t value); + inline ::uint64_t getEnd(); + inline void setEnd( ::uint64_t value); inline bool hasSingleRange(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>::Builder - getSingleRange(); - inline void setSingleRange(::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>::Builder - initSingleRange(unsigned int size); - inline void adoptSingleRange(::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>> - disownSingleRange(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Builder getSingleRange(); + inline void setSingleRange( ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Builder initSingleRange(unsigned int size); + inline void adoptSingleRange(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>> disownSingleRange(); inline bool hasMultiRange(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>::Builder - getMultiRange(); - inline void setMultiRange(::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>::Builder - initMultiRange(unsigned int size); - inline void adoptMultiRange(::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>> - disownMultiRange(); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Builder getMultiRange(); + inline void setMultiRange( ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Builder initMultiRange(unsigned int size); + inline void adoptMultiRange(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>> disownMultiRange(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -7947,17 +6310,14 @@ class SubarrayPartitioner::State::Builder { #if !CAPNP_LITE class SubarrayPartitioner::State::Pipeline { - public: +public: typedef State Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -7966,13 +6326,11 @@ class SubarrayPartitioner::State::Pipeline { #endif // !CAPNP_LITE class ReadState::Reader { - public: +public: typedef ReadState Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -7991,10 +6349,9 @@ class ReadState::Reader { inline bool getInitialized() const; inline bool hasSubarrayPartitioner() const; - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Reader - getSubarrayPartitioner() const; + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Reader getSubarrayPartitioner() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -8007,30 +6364,19 @@ class ReadState::Reader { }; class ReadState::Builder { - public: +public: typedef ReadState Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool getOverflowed(); @@ -8043,20 +6389,13 @@ class ReadState::Builder { inline void setInitialized(bool value); inline bool hasSubarrayPartitioner(); - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Builder - getSubarrayPartitioner(); - inline void setSubarrayPartitioner( - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Reader value); - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Builder - initSubarrayPartitioner(); - inline void adoptSubarrayPartitioner( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayPartitioner>&& - value); - inline ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner> - disownSubarrayPartitioner(); - - private: + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Builder getSubarrayPartitioner(); + inline void setSubarrayPartitioner( ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Reader value); + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Builder initSubarrayPartitioner(); + inline void adoptSubarrayPartitioner(::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner> disownSubarrayPartitioner(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8067,20 +6406,15 @@ class ReadState::Builder { #if !CAPNP_LITE class ReadState::Pipeline { - public: +public: typedef ReadState Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Pipeline - getSubarrayPartitioner(); - - private: + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Pipeline getSubarrayPartitioner(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -8089,13 +6423,11 @@ class ReadState::Pipeline { #endif // !CAPNP_LITE class ConditionClause::Reader { - public: +public: typedef ConditionClause Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -8108,17 +6440,17 @@ class ConditionClause::Reader { #endif // !CAPNP_LITE inline bool hasFieldName() const; - inline ::capnp::Text::Reader getFieldName() const; + inline ::capnp::Text::Reader getFieldName() const; inline bool hasValue() const; - inline ::capnp::Data::Reader getValue() const; + inline ::capnp::Data::Reader getValue() const; inline bool hasOp() const; - inline ::capnp::Text::Reader getOp() const; + inline ::capnp::Text::Reader getOp() const; inline bool getUseEnumeration() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -8131,57 +6463,46 @@ class ConditionClause::Reader { }; class ConditionClause::Builder { - public: +public: typedef ConditionClause Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasFieldName(); - inline ::capnp::Text::Builder getFieldName(); - inline void setFieldName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initFieldName(unsigned int size); - inline void adoptFieldName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownFieldName(); + inline ::capnp::Text::Builder getFieldName(); + inline void setFieldName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initFieldName(unsigned int size); + inline void adoptFieldName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownFieldName(); inline bool hasValue(); - inline ::capnp::Data::Builder getValue(); - inline void setValue(::capnp::Data::Reader value); - inline ::capnp::Data::Builder initValue(unsigned int size); - inline void adoptValue(::capnp::Orphan<::capnp::Data>&& value); - inline ::capnp::Orphan<::capnp::Data> disownValue(); + inline ::capnp::Data::Builder getValue(); + inline void setValue( ::capnp::Data::Reader value); + inline ::capnp::Data::Builder initValue(unsigned int size); + inline void adoptValue(::capnp::Orphan< ::capnp::Data>&& value); + inline ::capnp::Orphan< ::capnp::Data> disownValue(); inline bool hasOp(); - inline ::capnp::Text::Builder getOp(); - inline void setOp(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initOp(unsigned int size); - inline void adoptOp(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownOp(); + inline ::capnp::Text::Builder getOp(); + inline void setOp( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initOp(unsigned int size); + inline void adoptOp(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownOp(); inline bool getUseEnumeration(); inline void setUseEnumeration(bool value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8192,17 +6513,14 @@ class ConditionClause::Builder { #if !CAPNP_LITE class ConditionClause::Pipeline { - public: +public: typedef ConditionClause Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -8211,13 +6529,11 @@ class ConditionClause::Pipeline { #endif // !CAPNP_LITE class ASTNode::Reader { - public: +public: typedef ASTNode Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -8232,29 +6548,26 @@ class ASTNode::Reader { inline bool getIsExpression() const; inline bool hasFieldName() const; - inline ::capnp::Text::Reader getFieldName() const; + inline ::capnp::Text::Reader getFieldName() const; inline bool hasValue() const; - inline ::capnp::Data::Reader getValue() const; + inline ::capnp::Data::Reader getValue() const; inline bool hasOp() const; - inline ::capnp::Text::Reader getOp() const; + inline ::capnp::Text::Reader getOp() const; inline bool hasChildren() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>::Reader - getChildren() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>::Reader getChildren() const; inline bool hasCombinationOp() const; - inline ::capnp::Text::Reader getCombinationOp() const; + inline ::capnp::Text::Reader getCombinationOp() const; inline bool getUseEnumeration() const; inline bool hasOffsets() const; - inline ::capnp::Data::Reader getOffsets() const; + inline ::capnp::Data::Reader getOffsets() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -8267,94 +6580,70 @@ class ASTNode::Reader { }; class ASTNode::Builder { - public: +public: typedef ASTNode Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool getIsExpression(); inline void setIsExpression(bool value); inline bool hasFieldName(); - inline ::capnp::Text::Builder getFieldName(); - inline void setFieldName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initFieldName(unsigned int size); - inline void adoptFieldName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownFieldName(); + inline ::capnp::Text::Builder getFieldName(); + inline void setFieldName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initFieldName(unsigned int size); + inline void adoptFieldName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownFieldName(); inline bool hasValue(); - inline ::capnp::Data::Builder getValue(); - inline void setValue(::capnp::Data::Reader value); - inline ::capnp::Data::Builder initValue(unsigned int size); - inline void adoptValue(::capnp::Orphan<::capnp::Data>&& value); - inline ::capnp::Orphan<::capnp::Data> disownValue(); + inline ::capnp::Data::Builder getValue(); + inline void setValue( ::capnp::Data::Reader value); + inline ::capnp::Data::Builder initValue(unsigned int size); + inline void adoptValue(::capnp::Orphan< ::capnp::Data>&& value); + inline ::capnp::Orphan< ::capnp::Data> disownValue(); inline bool hasOp(); - inline ::capnp::Text::Builder getOp(); - inline void setOp(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initOp(unsigned int size); - inline void adoptOp(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownOp(); + inline ::capnp::Text::Builder getOp(); + inline void setOp( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initOp(unsigned int size); + inline void adoptOp(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownOp(); inline bool hasChildren(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>::Builder - getChildren(); - inline void setChildren(::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>::Builder - initChildren(unsigned int size); - inline void adoptChildren(::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>> - disownChildren(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>::Builder getChildren(); + inline void setChildren( ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>::Builder initChildren(unsigned int size); + inline void adoptChildren(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>> disownChildren(); inline bool hasCombinationOp(); - inline ::capnp::Text::Builder getCombinationOp(); - inline void setCombinationOp(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initCombinationOp(unsigned int size); - inline void adoptCombinationOp(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownCombinationOp(); + inline ::capnp::Text::Builder getCombinationOp(); + inline void setCombinationOp( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initCombinationOp(unsigned int size); + inline void adoptCombinationOp(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownCombinationOp(); inline bool getUseEnumeration(); inline void setUseEnumeration(bool value); inline bool hasOffsets(); - inline ::capnp::Data::Builder getOffsets(); - inline void setOffsets(::capnp::Data::Reader value); - inline ::capnp::Data::Builder initOffsets(unsigned int size); - inline void adoptOffsets(::capnp::Orphan<::capnp::Data>&& value); - inline ::capnp::Orphan<::capnp::Data> disownOffsets(); + inline ::capnp::Data::Builder getOffsets(); + inline void setOffsets( ::capnp::Data::Reader value); + inline ::capnp::Data::Builder initOffsets(unsigned int size); + inline void adoptOffsets(::capnp::Orphan< ::capnp::Data>&& value); + inline ::capnp::Orphan< ::capnp::Data> disownOffsets(); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8365,17 +6654,14 @@ class ASTNode::Builder { #if !CAPNP_LITE class ASTNode::Pipeline { - public: +public: typedef ASTNode Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -8384,13 +6670,11 @@ class ASTNode::Pipeline { #endif // !CAPNP_LITE class Condition::Reader { - public: +public: typedef Condition Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -8403,19 +6687,15 @@ class Condition::Reader { #endif // !CAPNP_LITE inline bool hasClauses() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>::Reader - getClauses() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>::Reader getClauses() const; inline bool hasClauseCombinationOps() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getClauseCombinationOps() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getClauseCombinationOps() const; inline bool hasTree() const; - inline ::tiledb::sm::serialization::capnp::ASTNode::Reader getTree() const; + inline ::tiledb::sm::serialization::capnp::ASTNode::Reader getTree() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -8428,79 +6708,44 @@ class Condition::Reader { }; class Condition::Builder { - public: +public: typedef Condition Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasClauses(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>::Builder - getClauses(); - inline void setClauses(::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>::Builder - initClauses(unsigned int size); - inline void adoptClauses( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>> - disownClauses(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>::Builder getClauses(); + inline void setClauses( ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>::Builder initClauses(unsigned int size); + inline void adoptClauses(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>> disownClauses(); inline bool hasClauseCombinationOps(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getClauseCombinationOps(); - inline void setClauseCombinationOps( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setClauseCombinationOps( - ::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initClauseCombinationOps(unsigned int size); - inline void adoptClauseCombinationOps( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownClauseCombinationOps(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getClauseCombinationOps(); + inline void setClauseCombinationOps( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setClauseCombinationOps(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initClauseCombinationOps(unsigned int size); + inline void adoptClauseCombinationOps(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownClauseCombinationOps(); inline bool hasTree(); - inline ::tiledb::sm::serialization::capnp::ASTNode::Builder getTree(); - inline void setTree( - ::tiledb::sm::serialization::capnp::ASTNode::Reader value); - inline ::tiledb::sm::serialization::capnp::ASTNode::Builder initTree(); - inline void adoptTree( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ASTNode>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ASTNode> - disownTree(); - - private: + inline ::tiledb::sm::serialization::capnp::ASTNode::Builder getTree(); + inline void setTree( ::tiledb::sm::serialization::capnp::ASTNode::Reader value); + inline ::tiledb::sm::serialization::capnp::ASTNode::Builder initTree(); + inline void adoptTree(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ASTNode>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ASTNode> disownTree(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8511,19 +6756,15 @@ class Condition::Builder { #if !CAPNP_LITE class Condition::Pipeline { - public: +public: typedef Condition Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::ASTNode::Pipeline getTree(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::ASTNode::Pipeline getTree(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -8532,13 +6773,11 @@ class Condition::Pipeline { #endif // !CAPNP_LITE class QueryReader::Reader { - public: +public: typedef QueryReader Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -8551,26 +6790,23 @@ class QueryReader::Reader { #endif // !CAPNP_LITE inline bool hasLayout() const; - inline ::capnp::Text::Reader getLayout() const; + inline ::capnp::Text::Reader getLayout() const; inline bool hasSubarray() const; - inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarray() - const; + inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarray() const; inline bool hasReadState() const; - inline ::tiledb::sm::serialization::capnp::ReadState::Reader getReadState() - const; + inline ::tiledb::sm::serialization::capnp::ReadState::Reader getReadState() const; inline bool hasCondition() const; - inline ::tiledb::sm::serialization::capnp::Condition::Reader getCondition() - const; + inline ::tiledb::sm::serialization::capnp::Condition::Reader getCondition() const; inline bool hasStats() const; - inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; + inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; inline bool getDimLabelIncreasing() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -8583,82 +6819,60 @@ class QueryReader::Reader { }; class QueryReader::Builder { - public: +public: typedef QueryReader Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasLayout(); - inline ::capnp::Text::Builder getLayout(); - inline void setLayout(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initLayout(unsigned int size); - inline void adoptLayout(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownLayout(); + inline ::capnp::Text::Builder getLayout(); + inline void setLayout( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initLayout(unsigned int size); + inline void adoptLayout(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownLayout(); inline bool hasSubarray(); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarray(); - inline void setSubarray( - ::tiledb::sm::serialization::capnp::Subarray::Reader value); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarray(); - inline void adoptSubarray( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> - disownSubarray(); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarray(); + inline void setSubarray( ::tiledb::sm::serialization::capnp::Subarray::Reader value); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarray(); + inline void adoptSubarray(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> disownSubarray(); inline bool hasReadState(); - inline ::tiledb::sm::serialization::capnp::ReadState::Builder getReadState(); - inline void setReadState( - ::tiledb::sm::serialization::capnp::ReadState::Reader value); - inline ::tiledb::sm::serialization::capnp::ReadState::Builder initReadState(); - inline void adoptReadState( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReadState>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReadState> - disownReadState(); + inline ::tiledb::sm::serialization::capnp::ReadState::Builder getReadState(); + inline void setReadState( ::tiledb::sm::serialization::capnp::ReadState::Reader value); + inline ::tiledb::sm::serialization::capnp::ReadState::Builder initReadState(); + inline void adoptReadState(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReadState>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReadState> disownReadState(); inline bool hasCondition(); - inline ::tiledb::sm::serialization::capnp::Condition::Builder getCondition(); - inline void setCondition( - ::tiledb::sm::serialization::capnp::Condition::Reader value); - inline ::tiledb::sm::serialization::capnp::Condition::Builder initCondition(); - inline void adoptCondition( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition> - disownCondition(); + inline ::tiledb::sm::serialization::capnp::Condition::Builder getCondition(); + inline void setCondition( ::tiledb::sm::serialization::capnp::Condition::Reader value); + inline ::tiledb::sm::serialization::capnp::Condition::Builder initCondition(); + inline void adoptCondition(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition> disownCondition(); inline bool hasStats(); - inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); - inline void setStats(::tiledb::sm::serialization::capnp::Stats::Reader value); - inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); - inline void adoptStats( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> - disownStats(); + inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); + inline void setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value); + inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); + inline void adoptStats(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> disownStats(); inline bool getDimLabelIncreasing(); inline void setDimLabelIncreasing(bool value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8669,22 +6883,18 @@ class QueryReader::Builder { #if !CAPNP_LITE class QueryReader::Pipeline { - public: +public: typedef QueryReader Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarray(); - inline ::tiledb::sm::serialization::capnp::ReadState::Pipeline getReadState(); - inline ::tiledb::sm::serialization::capnp::Condition::Pipeline getCondition(); - inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarray(); + inline ::tiledb::sm::serialization::capnp::ReadState::Pipeline getReadState(); + inline ::tiledb::sm::serialization::capnp::Condition::Pipeline getCondition(); + inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -8693,13 +6903,11 @@ class QueryReader::Pipeline { #endif // !CAPNP_LITE class Delete::Reader { - public: +public: typedef Delete Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -8712,13 +6920,12 @@ class Delete::Reader { #endif // !CAPNP_LITE inline bool hasCondition() const; - inline ::tiledb::sm::serialization::capnp::Condition::Reader getCondition() - const; + inline ::tiledb::sm::serialization::capnp::Condition::Reader getCondition() const; inline bool hasStats() const; - inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; + inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -8731,52 +6938,36 @@ class Delete::Reader { }; class Delete::Builder { - public: +public: typedef Delete Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasCondition(); - inline ::tiledb::sm::serialization::capnp::Condition::Builder getCondition(); - inline void setCondition( - ::tiledb::sm::serialization::capnp::Condition::Reader value); - inline ::tiledb::sm::serialization::capnp::Condition::Builder initCondition(); - inline void adoptCondition( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition> - disownCondition(); + inline ::tiledb::sm::serialization::capnp::Condition::Builder getCondition(); + inline void setCondition( ::tiledb::sm::serialization::capnp::Condition::Reader value); + inline ::tiledb::sm::serialization::capnp::Condition::Builder initCondition(); + inline void adoptCondition(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition> disownCondition(); inline bool hasStats(); - inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); - inline void setStats(::tiledb::sm::serialization::capnp::Stats::Reader value); - inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); - inline void adoptStats( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> - disownStats(); - - private: + inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); + inline void setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value); + inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); + inline void adoptStats(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> disownStats(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8787,20 +6978,16 @@ class Delete::Builder { #if !CAPNP_LITE class Delete::Pipeline { - public: +public: typedef Delete Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::Condition::Pipeline getCondition(); - inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); - - private: + inline ::tiledb::sm::serialization::capnp::Condition::Pipeline getCondition(); + inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -8809,13 +6996,11 @@ class Delete::Pipeline { #endif // !CAPNP_LITE class ResultCellSlab::Reader { - public: +public: typedef ResultCellSlab Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -8827,15 +7012,15 @@ class ResultCellSlab::Reader { } #endif // !CAPNP_LITE - inline ::uint32_t getFragIdx() const; + inline ::uint32_t getFragIdx() const; - inline ::uint64_t getTileIdx() const; + inline ::uint64_t getTileIdx() const; - inline ::uint64_t getStart() const; + inline ::uint64_t getStart() const; - inline ::uint64_t getLength() const; + inline ::uint64_t getLength() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -8848,45 +7033,34 @@ class ResultCellSlab::Reader { }; class ResultCellSlab::Builder { - public: +public: typedef ResultCellSlab Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE - inline ::uint32_t getFragIdx(); - inline void setFragIdx(::uint32_t value); + inline ::uint32_t getFragIdx(); + inline void setFragIdx( ::uint32_t value); - inline ::uint64_t getTileIdx(); - inline void setTileIdx(::uint64_t value); + inline ::uint64_t getTileIdx(); + inline void setTileIdx( ::uint64_t value); - inline ::uint64_t getStart(); - inline void setStart(::uint64_t value); + inline ::uint64_t getStart(); + inline void setStart( ::uint64_t value); - inline ::uint64_t getLength(); - inline void setLength(::uint64_t value); + inline ::uint64_t getLength(); + inline void setLength( ::uint64_t value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8897,17 +7071,14 @@ class ResultCellSlab::Builder { #if !CAPNP_LITE class ResultCellSlab::Pipeline { - public: +public: typedef ResultCellSlab Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -8916,13 +7087,11 @@ class ResultCellSlab::Pipeline { #endif // !CAPNP_LITE class FragmentIndex::Reader { - public: +public: typedef FragmentIndex Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -8934,11 +7103,11 @@ class FragmentIndex::Reader { } #endif // !CAPNP_LITE - inline ::uint64_t getTileIdx() const; + inline ::uint64_t getTileIdx() const; - inline ::uint64_t getCellIdx() const; + inline ::uint64_t getCellIdx() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -8951,39 +7120,28 @@ class FragmentIndex::Reader { }; class FragmentIndex::Builder { - public: +public: typedef FragmentIndex Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE - inline ::uint64_t getTileIdx(); - inline void setTileIdx(::uint64_t value); + inline ::uint64_t getTileIdx(); + inline void setTileIdx( ::uint64_t value); - inline ::uint64_t getCellIdx(); - inline void setCellIdx(::uint64_t value); + inline ::uint64_t getCellIdx(); + inline void setCellIdx( ::uint64_t value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8994,17 +7152,14 @@ class FragmentIndex::Builder { #if !CAPNP_LITE class FragmentIndex::Pipeline { - public: +public: typedef FragmentIndex Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -9013,13 +7168,11 @@ class FragmentIndex::Pipeline { #endif // !CAPNP_LITE class ReadStateIndex::Reader { - public: +public: typedef ReadStateIndex Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -9032,20 +7185,14 @@ class ReadStateIndex::Reader { #endif // !CAPNP_LITE inline bool hasResultCellSlab() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>::Reader - getResultCellSlab() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>::Reader getResultCellSlab() const; inline bool hasFragTileIdx() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>::Reader - getFragTileIdx() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>::Reader getFragTileIdx() const; inline bool getDoneAddingResultTiles() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -9058,79 +7205,39 @@ class ReadStateIndex::Reader { }; class ReadStateIndex::Builder { - public: +public: typedef ReadStateIndex Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasResultCellSlab(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>::Builder - getResultCellSlab(); - inline void setResultCellSlab( - ::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>::Builder - initResultCellSlab(unsigned int size); - inline void adoptResultCellSlab( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>> - disownResultCellSlab(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>::Builder getResultCellSlab(); + inline void setResultCellSlab( ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>::Builder initResultCellSlab(unsigned int size); + inline void adoptResultCellSlab(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>> disownResultCellSlab(); inline bool hasFragTileIdx(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>::Builder - getFragTileIdx(); - inline void setFragTileIdx(::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>::Builder - initFragTileIdx(unsigned int size); - inline void adoptFragTileIdx( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>> - disownFragTileIdx(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>::Builder getFragTileIdx(); + inline void setFragTileIdx( ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>::Builder initFragTileIdx(unsigned int size); + inline void adoptFragTileIdx(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>> disownFragTileIdx(); inline bool getDoneAddingResultTiles(); inline void setDoneAddingResultTiles(bool value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -9141,17 +7248,90 @@ class ReadStateIndex::Builder { #if !CAPNP_LITE class ReadStateIndex::Pipeline { - public: +public: typedef ReadStateIndex Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + +class PreprocessTileOrder::Reader { +public: + typedef PreprocessTileOrder Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); } +#endif // !CAPNP_LITE + + inline ::uint64_t getCursor() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class PreprocessTileOrder::Builder { +public: + typedef PreprocessTileOrder Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { return asReader().toString(); } +#endif // !CAPNP_LITE + + inline ::uint64_t getCursor(); + inline void setCursor( ::uint64_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class PreprocessTileOrder::Pipeline { +public: + typedef PreprocessTileOrder Pipelines; - private: + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -9160,13 +7340,11 @@ class ReadStateIndex::Pipeline { #endif // !CAPNP_LITE class ReaderIndex::Reader { - public: +public: typedef ReaderIndex Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -9179,24 +7357,24 @@ class ReaderIndex::Reader { #endif // !CAPNP_LITE inline bool hasLayout() const; - inline ::capnp::Text::Reader getLayout() const; + inline ::capnp::Text::Reader getLayout() const; inline bool hasSubarray() const; - inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarray() - const; + inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarray() const; inline bool hasReadState() const; - inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Reader - getReadState() const; + inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Reader getReadState() const; inline bool hasCondition() const; - inline ::tiledb::sm::serialization::capnp::Condition::Reader getCondition() - const; + inline ::tiledb::sm::serialization::capnp::Condition::Reader getCondition() const; inline bool hasStats() const; - inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; + inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; + + inline bool hasPreprocess() const; + inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Reader getPreprocess() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -9209,82 +7387,64 @@ class ReaderIndex::Reader { }; class ReaderIndex::Builder { - public: +public: typedef ReaderIndex Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasLayout(); - inline ::capnp::Text::Builder getLayout(); - inline void setLayout(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initLayout(unsigned int size); - inline void adoptLayout(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownLayout(); + inline ::capnp::Text::Builder getLayout(); + inline void setLayout( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initLayout(unsigned int size); + inline void adoptLayout(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownLayout(); inline bool hasSubarray(); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarray(); - inline void setSubarray( - ::tiledb::sm::serialization::capnp::Subarray::Reader value); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarray(); - inline void adoptSubarray( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> - disownSubarray(); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarray(); + inline void setSubarray( ::tiledb::sm::serialization::capnp::Subarray::Reader value); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarray(); + inline void adoptSubarray(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> disownSubarray(); inline bool hasReadState(); - inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Builder - getReadState(); - inline void setReadState( - ::tiledb::sm::serialization::capnp::ReadStateIndex::Reader value); - inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Builder - initReadState(); - inline void adoptReadState( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReadStateIndex>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReadStateIndex> - disownReadState(); + inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Builder getReadState(); + inline void setReadState( ::tiledb::sm::serialization::capnp::ReadStateIndex::Reader value); + inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Builder initReadState(); + inline void adoptReadState(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReadStateIndex>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReadStateIndex> disownReadState(); inline bool hasCondition(); - inline ::tiledb::sm::serialization::capnp::Condition::Builder getCondition(); - inline void setCondition( - ::tiledb::sm::serialization::capnp::Condition::Reader value); - inline ::tiledb::sm::serialization::capnp::Condition::Builder initCondition(); - inline void adoptCondition( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition> - disownCondition(); + inline ::tiledb::sm::serialization::capnp::Condition::Builder getCondition(); + inline void setCondition( ::tiledb::sm::serialization::capnp::Condition::Reader value); + inline ::tiledb::sm::serialization::capnp::Condition::Builder initCondition(); + inline void adoptCondition(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition> disownCondition(); inline bool hasStats(); - inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); - inline void setStats(::tiledb::sm::serialization::capnp::Stats::Reader value); - inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); - inline void adoptStats( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> - disownStats(); - - private: + inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); + inline void setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value); + inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); + inline void adoptStats(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> disownStats(); + + inline bool hasPreprocess(); + inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Builder getPreprocess(); + inline void setPreprocess( ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Reader value); + inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Builder initPreprocess(); + inline void adoptPreprocess(::capnp::Orphan< ::tiledb::sm::serialization::capnp::PreprocessTileOrder>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::PreprocessTileOrder> disownPreprocess(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -9295,23 +7455,19 @@ class ReaderIndex::Builder { #if !CAPNP_LITE class ReaderIndex::Pipeline { - public: +public: typedef ReaderIndex Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarray(); - inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Pipeline - getReadState(); - inline ::tiledb::sm::serialization::capnp::Condition::Pipeline getCondition(); - inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); - - private: + : _typeless(kj::mv(typeless)) {} + + inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarray(); + inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Pipeline getReadState(); + inline ::tiledb::sm::serialization::capnp::Condition::Pipeline getCondition(); + inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); + inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Pipeline getPreprocess(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -9320,13 +7476,11 @@ class ReaderIndex::Pipeline { #endif // !CAPNP_LITE class Query::Reader { - public: +public: typedef Query Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -9339,81 +7493,67 @@ class Query::Reader { #endif // !CAPNP_LITE inline bool hasAttributeBufferHeaders() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>::Reader - getAttributeBufferHeaders() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>::Reader getAttributeBufferHeaders() const; inline bool hasLayout() const; - inline ::capnp::Text::Reader getLayout() const; + inline ::capnp::Text::Reader getLayout() const; inline bool hasStatus() const; - inline ::capnp::Text::Reader getStatus() const; + inline ::capnp::Text::Reader getStatus() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; inline bool hasWriter() const; - inline ::tiledb::sm::serialization::capnp::Writer::Reader getWriter() const; + inline ::tiledb::sm::serialization::capnp::Writer::Reader getWriter() const; inline bool hasReader() const; - inline ::tiledb::sm::serialization::capnp::QueryReader::Reader getReader() - const; + inline ::tiledb::sm::serialization::capnp::QueryReader::Reader getReader() const; inline bool hasArray() const; - inline ::tiledb::sm::serialization::capnp::Array::Reader getArray() const; + inline ::tiledb::sm::serialization::capnp::Array::Reader getArray() const; - inline ::uint64_t getTotalFixedLengthBufferBytes() const; + inline ::uint64_t getTotalFixedLengthBufferBytes() const; - inline ::uint64_t getTotalVarLenBufferBytes() const; + inline ::uint64_t getTotalVarLenBufferBytes() const; - inline ::uint64_t getTotalValidityBufferBytes() const; + inline ::uint64_t getTotalValidityBufferBytes() const; inline bool hasVarOffsetsMode() const; - inline ::capnp::Text::Reader getVarOffsetsMode() const; + inline ::capnp::Text::Reader getVarOffsetsMode() const; inline bool getVarOffsetsAddExtraElement() const; - inline ::int32_t getVarOffsetsBitsize() const; + inline ::int32_t getVarOffsetsBitsize() const; inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasStats() const; - inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; + inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; inline bool hasReaderIndex() const; - inline ::tiledb::sm::serialization::capnp::ReaderIndex::Reader - getReaderIndex() const; + inline ::tiledb::sm::serialization::capnp::ReaderIndex::Reader getReaderIndex() const; inline bool hasDenseReader() const; - inline ::tiledb::sm::serialization::capnp::QueryReader::Reader - getDenseReader() const; + inline ::tiledb::sm::serialization::capnp::QueryReader::Reader getDenseReader() const; inline bool hasDelete() const; - inline ::tiledb::sm::serialization::capnp::Delete::Reader getDelete() const; + inline ::tiledb::sm::serialization::capnp::Delete::Reader getDelete() const; inline bool hasWrittenFragmentInfo() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>::Reader - getWrittenFragmentInfo() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>::Reader getWrittenFragmentInfo() const; inline bool hasWrittenBuffers() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getWrittenBuffers() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getWrittenBuffers() const; inline bool hasOrderedDimLabelReader() const; - inline ::tiledb::sm::serialization::capnp::QueryReader::Reader - getOrderedDimLabelReader() const; + inline ::tiledb::sm::serialization::capnp::QueryReader::Reader getOrderedDimLabelReader() const; inline bool hasChannels() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>::Reader - getChannels() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>::Reader getChannels() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -9426,250 +7566,157 @@ class Query::Reader { }; class Query::Builder { - public: +public: typedef Query Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasAttributeBufferHeaders(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>::Builder - getAttributeBufferHeaders(); - inline void setAttributeBufferHeaders( - ::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>::Builder - initAttributeBufferHeaders(unsigned int size); - inline void adoptAttributeBufferHeaders( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>> - disownAttributeBufferHeaders(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>::Builder getAttributeBufferHeaders(); + inline void setAttributeBufferHeaders( ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>::Builder initAttributeBufferHeaders(unsigned int size); + inline void adoptAttributeBufferHeaders(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>> disownAttributeBufferHeaders(); inline bool hasLayout(); - inline ::capnp::Text::Builder getLayout(); - inline void setLayout(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initLayout(unsigned int size); - inline void adoptLayout(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownLayout(); + inline ::capnp::Text::Builder getLayout(); + inline void setLayout( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initLayout(unsigned int size); + inline void adoptLayout(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownLayout(); inline bool hasStatus(); - inline ::capnp::Text::Builder getStatus(); - inline void setStatus(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initStatus(unsigned int size); - inline void adoptStatus(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownStatus(); + inline ::capnp::Text::Builder getStatus(); + inline void setStatus( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initStatus(unsigned int size); + inline void adoptStatus(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownStatus(); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownType(); inline bool hasWriter(); - inline ::tiledb::sm::serialization::capnp::Writer::Builder getWriter(); - inline void setWriter( - ::tiledb::sm::serialization::capnp::Writer::Reader value); - inline ::tiledb::sm::serialization::capnp::Writer::Builder initWriter(); - inline void adoptWriter( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Writer>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Writer> - disownWriter(); + inline ::tiledb::sm::serialization::capnp::Writer::Builder getWriter(); + inline void setWriter( ::tiledb::sm::serialization::capnp::Writer::Reader value); + inline ::tiledb::sm::serialization::capnp::Writer::Builder initWriter(); + inline void adoptWriter(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Writer>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Writer> disownWriter(); inline bool hasReader(); - inline ::tiledb::sm::serialization::capnp::QueryReader::Builder getReader(); - inline void setReader( - ::tiledb::sm::serialization::capnp::QueryReader::Reader value); - inline ::tiledb::sm::serialization::capnp::QueryReader::Builder initReader(); - inline void adoptReader( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader> - disownReader(); + inline ::tiledb::sm::serialization::capnp::QueryReader::Builder getReader(); + inline void setReader( ::tiledb::sm::serialization::capnp::QueryReader::Reader value); + inline ::tiledb::sm::serialization::capnp::QueryReader::Builder initReader(); + inline void adoptReader(::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader> disownReader(); inline bool hasArray(); - inline ::tiledb::sm::serialization::capnp::Array::Builder getArray(); - inline void setArray(::tiledb::sm::serialization::capnp::Array::Reader value); - inline ::tiledb::sm::serialization::capnp::Array::Builder initArray(); - inline void adoptArray( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Array>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Array> - disownArray(); + inline ::tiledb::sm::serialization::capnp::Array::Builder getArray(); + inline void setArray( ::tiledb::sm::serialization::capnp::Array::Reader value); + inline ::tiledb::sm::serialization::capnp::Array::Builder initArray(); + inline void adoptArray(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Array>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Array> disownArray(); - inline ::uint64_t getTotalFixedLengthBufferBytes(); - inline void setTotalFixedLengthBufferBytes(::uint64_t value); + inline ::uint64_t getTotalFixedLengthBufferBytes(); + inline void setTotalFixedLengthBufferBytes( ::uint64_t value); - inline ::uint64_t getTotalVarLenBufferBytes(); - inline void setTotalVarLenBufferBytes(::uint64_t value); + inline ::uint64_t getTotalVarLenBufferBytes(); + inline void setTotalVarLenBufferBytes( ::uint64_t value); - inline ::uint64_t getTotalValidityBufferBytes(); - inline void setTotalValidityBufferBytes(::uint64_t value); + inline ::uint64_t getTotalValidityBufferBytes(); + inline void setTotalValidityBufferBytes( ::uint64_t value); inline bool hasVarOffsetsMode(); - inline ::capnp::Text::Builder getVarOffsetsMode(); - inline void setVarOffsetsMode(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initVarOffsetsMode(unsigned int size); - inline void adoptVarOffsetsMode(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownVarOffsetsMode(); + inline ::capnp::Text::Builder getVarOffsetsMode(); + inline void setVarOffsetsMode( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initVarOffsetsMode(unsigned int size); + inline void adoptVarOffsetsMode(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownVarOffsetsMode(); inline bool getVarOffsetsAddExtraElement(); inline void setVarOffsetsAddExtraElement(bool value); - inline ::int32_t getVarOffsetsBitsize(); - inline void setVarOffsetsBitsize(::int32_t value); + inline ::int32_t getVarOffsetsBitsize(); + inline void setVarOffsetsBitsize( ::int32_t value); inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> - disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); inline bool hasStats(); - inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); - inline void setStats(::tiledb::sm::serialization::capnp::Stats::Reader value); - inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); - inline void adoptStats( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> - disownStats(); + inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); + inline void setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value); + inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); + inline void adoptStats(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> disownStats(); inline bool hasReaderIndex(); - inline ::tiledb::sm::serialization::capnp::ReaderIndex::Builder - getReaderIndex(); - inline void setReaderIndex( - ::tiledb::sm::serialization::capnp::ReaderIndex::Reader value); - inline ::tiledb::sm::serialization::capnp::ReaderIndex::Builder - initReaderIndex(); - inline void adoptReaderIndex( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReaderIndex>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReaderIndex> - disownReaderIndex(); + inline ::tiledb::sm::serialization::capnp::ReaderIndex::Builder getReaderIndex(); + inline void setReaderIndex( ::tiledb::sm::serialization::capnp::ReaderIndex::Reader value); + inline ::tiledb::sm::serialization::capnp::ReaderIndex::Builder initReaderIndex(); + inline void adoptReaderIndex(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReaderIndex>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReaderIndex> disownReaderIndex(); inline bool hasDenseReader(); - inline ::tiledb::sm::serialization::capnp::QueryReader::Builder - getDenseReader(); - inline void setDenseReader( - ::tiledb::sm::serialization::capnp::QueryReader::Reader value); - inline ::tiledb::sm::serialization::capnp::QueryReader::Builder - initDenseReader(); - inline void adoptDenseReader( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader> - disownDenseReader(); + inline ::tiledb::sm::serialization::capnp::QueryReader::Builder getDenseReader(); + inline void setDenseReader( ::tiledb::sm::serialization::capnp::QueryReader::Reader value); + inline ::tiledb::sm::serialization::capnp::QueryReader::Builder initDenseReader(); + inline void adoptDenseReader(::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader> disownDenseReader(); inline bool hasDelete(); - inline ::tiledb::sm::serialization::capnp::Delete::Builder getDelete(); - inline void setDelete( - ::tiledb::sm::serialization::capnp::Delete::Reader value); - inline ::tiledb::sm::serialization::capnp::Delete::Builder initDelete(); - inline void adoptDelete( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Delete>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Delete> - disownDelete(); + inline ::tiledb::sm::serialization::capnp::Delete::Builder getDelete(); + inline void setDelete( ::tiledb::sm::serialization::capnp::Delete::Reader value); + inline ::tiledb::sm::serialization::capnp::Delete::Builder initDelete(); + inline void adoptDelete(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Delete>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Delete> disownDelete(); inline bool hasWrittenFragmentInfo(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>::Builder - getWrittenFragmentInfo(); - inline void setWrittenFragmentInfo( - ::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>::Builder - initWrittenFragmentInfo(unsigned int size); - inline void adoptWrittenFragmentInfo( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>> - disownWrittenFragmentInfo(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>::Builder getWrittenFragmentInfo(); + inline void setWrittenFragmentInfo( ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>::Builder initWrittenFragmentInfo(unsigned int size); + inline void adoptWrittenFragmentInfo(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>> disownWrittenFragmentInfo(); inline bool hasWrittenBuffers(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getWrittenBuffers(); - inline void setWrittenBuffers( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setWrittenBuffers( - ::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initWrittenBuffers(unsigned int size); - inline void adoptWrittenBuffers( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownWrittenBuffers(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getWrittenBuffers(); + inline void setWrittenBuffers( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setWrittenBuffers(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initWrittenBuffers(unsigned int size); + inline void adoptWrittenBuffers(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownWrittenBuffers(); inline bool hasOrderedDimLabelReader(); - inline ::tiledb::sm::serialization::capnp::QueryReader::Builder - getOrderedDimLabelReader(); - inline void setOrderedDimLabelReader( - ::tiledb::sm::serialization::capnp::QueryReader::Reader value); - inline ::tiledb::sm::serialization::capnp::QueryReader::Builder - initOrderedDimLabelReader(); - inline void adoptOrderedDimLabelReader( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader> - disownOrderedDimLabelReader(); + inline ::tiledb::sm::serialization::capnp::QueryReader::Builder getOrderedDimLabelReader(); + inline void setOrderedDimLabelReader( ::tiledb::sm::serialization::capnp::QueryReader::Reader value); + inline ::tiledb::sm::serialization::capnp::QueryReader::Builder initOrderedDimLabelReader(); + inline void adoptOrderedDimLabelReader(::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader> disownOrderedDimLabelReader(); inline bool hasChannels(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>::Builder - getChannels(); - inline void setChannels(::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>::Builder - initChannels(unsigned int size); - inline void adoptChannels( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>> - disownChannels(); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>::Builder getChannels(); + inline void setChannels( ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>::Builder initChannels(unsigned int size); + inline void adoptChannels(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>> disownChannels(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -9680,30 +7727,23 @@ class Query::Builder { #if !CAPNP_LITE class Query::Pipeline { - public: +public: typedef Query Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::Writer::Pipeline getWriter(); - inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline getReader(); - inline ::tiledb::sm::serialization::capnp::Array::Pipeline getArray(); - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); - inline ::tiledb::sm::serialization::capnp::ReaderIndex::Pipeline - getReaderIndex(); - inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline - getDenseReader(); - inline ::tiledb::sm::serialization::capnp::Delete::Pipeline getDelete(); - inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline - getOrderedDimLabelReader(); - - private: + : _typeless(kj::mv(typeless)) {} + + inline ::tiledb::sm::serialization::capnp::Writer::Pipeline getWriter(); + inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline getReader(); + inline ::tiledb::sm::serialization::capnp::Array::Pipeline getArray(); + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); + inline ::tiledb::sm::serialization::capnp::ReaderIndex::Pipeline getReaderIndex(); + inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline getDenseReader(); + inline ::tiledb::sm::serialization::capnp::Delete::Pipeline getDelete(); + inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline getOrderedDimLabelReader(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -9712,13 +7752,11 @@ class Query::Pipeline { #endif // !CAPNP_LITE class NonEmptyDomain::Reader { - public: +public: typedef NonEmptyDomain Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -9731,16 +7769,14 @@ class NonEmptyDomain::Reader { #endif // !CAPNP_LITE inline bool hasNonEmptyDomain() const; - inline ::tiledb::sm::serialization::capnp::DomainArray::Reader - getNonEmptyDomain() const; + inline ::tiledb::sm::serialization::capnp::DomainArray::Reader getNonEmptyDomain() const; inline bool getIsEmpty() const; inline bool hasSizes() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getSizes() - const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getSizes() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -9753,62 +7789,40 @@ class NonEmptyDomain::Reader { }; class NonEmptyDomain::Builder { - public: +public: typedef NonEmptyDomain Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasNonEmptyDomain(); - inline ::tiledb::sm::serialization::capnp::DomainArray::Builder - getNonEmptyDomain(); - inline void setNonEmptyDomain( - ::tiledb::sm::serialization::capnp::DomainArray::Reader value); - inline ::tiledb::sm::serialization::capnp::DomainArray::Builder - initNonEmptyDomain(); - inline void adoptNonEmptyDomain( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray> - disownNonEmptyDomain(); + inline ::tiledb::sm::serialization::capnp::DomainArray::Builder getNonEmptyDomain(); + inline void setNonEmptyDomain( ::tiledb::sm::serialization::capnp::DomainArray::Reader value); + inline ::tiledb::sm::serialization::capnp::DomainArray::Builder initNonEmptyDomain(); + inline void adoptNonEmptyDomain(::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray> disownNonEmptyDomain(); inline bool getIsEmpty(); inline void setIsEmpty(bool value); inline bool hasSizes(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getSizes(); - inline void setSizes( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setSizes(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initSizes( - unsigned int size); - inline void adoptSizes( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownSizes(); - - private: + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getSizes(); + inline void setSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setSizes(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initSizes(unsigned int size); + inline void adoptSizes(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownSizes(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -9819,20 +7833,15 @@ class NonEmptyDomain::Builder { #if !CAPNP_LITE class NonEmptyDomain::Pipeline { - public: +public: typedef NonEmptyDomain Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline - getNonEmptyDomain(); - - private: + inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline getNonEmptyDomain(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -9841,13 +7850,11 @@ class NonEmptyDomain::Pipeline { #endif // !CAPNP_LITE class NonEmptyDomainList::Reader { - public: +public: typedef NonEmptyDomainList Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -9860,12 +7867,9 @@ class NonEmptyDomainList::Reader { #endif // !CAPNP_LITE inline bool hasNonEmptyDomains() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>::Reader - getNonEmptyDomains() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>::Reader getNonEmptyDomains() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -9878,55 +7882,29 @@ class NonEmptyDomainList::Reader { }; class NonEmptyDomainList::Builder { - public: +public: typedef NonEmptyDomainList Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasNonEmptyDomains(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>::Builder - getNonEmptyDomains(); - inline void setNonEmptyDomains( - ::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>::Builder - initNonEmptyDomains(unsigned int size); - inline void adoptNonEmptyDomains( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>> - disownNonEmptyDomains(); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>::Builder getNonEmptyDomains(); + inline void setNonEmptyDomains( ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>::Builder initNonEmptyDomains(unsigned int size); + inline void adoptNonEmptyDomains(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>> disownNonEmptyDomains(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -9937,17 +7915,14 @@ class NonEmptyDomainList::Builder { #if !CAPNP_LITE class NonEmptyDomainList::Pipeline { - public: +public: typedef NonEmptyDomainList Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -9956,13 +7931,11 @@ class NonEmptyDomainList::Pipeline { #endif // !CAPNP_LITE class AttributeBufferSize::Reader { - public: +public: typedef AttributeBufferSize Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -9975,15 +7948,15 @@ class AttributeBufferSize::Reader { #endif // !CAPNP_LITE inline bool hasAttribute() const; - inline ::capnp::Text::Reader getAttribute() const; + inline ::capnp::Text::Reader getAttribute() const; - inline ::uint64_t getOffsetBytes() const; + inline ::uint64_t getOffsetBytes() const; - inline ::uint64_t getDataBytes() const; + inline ::uint64_t getDataBytes() const; - inline ::uint64_t getValidityBytes() const; + inline ::uint64_t getValidityBytes() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -9996,49 +7969,38 @@ class AttributeBufferSize::Reader { }; class AttributeBufferSize::Builder { - public: +public: typedef AttributeBufferSize Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasAttribute(); - inline ::capnp::Text::Builder getAttribute(); - inline void setAttribute(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initAttribute(unsigned int size); - inline void adoptAttribute(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownAttribute(); + inline ::capnp::Text::Builder getAttribute(); + inline void setAttribute( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initAttribute(unsigned int size); + inline void adoptAttribute(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownAttribute(); - inline ::uint64_t getOffsetBytes(); - inline void setOffsetBytes(::uint64_t value); + inline ::uint64_t getOffsetBytes(); + inline void setOffsetBytes( ::uint64_t value); - inline ::uint64_t getDataBytes(); - inline void setDataBytes(::uint64_t value); + inline ::uint64_t getDataBytes(); + inline void setDataBytes( ::uint64_t value); - inline ::uint64_t getValidityBytes(); - inline void setValidityBytes(::uint64_t value); + inline ::uint64_t getValidityBytes(); + inline void setValidityBytes( ::uint64_t value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -10049,17 +8011,14 @@ class AttributeBufferSize::Builder { #if !CAPNP_LITE class AttributeBufferSize::Pipeline { - public: +public: typedef AttributeBufferSize Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -10068,13 +8027,11 @@ class AttributeBufferSize::Pipeline { #endif // !CAPNP_LITE class ArrayMetadata::Reader { - public: +public: typedef ArrayMetadata Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -10087,12 +8044,9 @@ class ArrayMetadata::Reader { #endif // !CAPNP_LITE inline bool hasEntries() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>::Reader - getEntries() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>::Reader getEntries() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -10105,55 +8059,29 @@ class ArrayMetadata::Reader { }; class ArrayMetadata::Builder { - public: +public: typedef ArrayMetadata Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasEntries(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>::Builder - getEntries(); - inline void setEntries( - ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>::Builder - initEntries(unsigned int size); - inline void adoptEntries( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>> - disownEntries(); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>::Builder getEntries(); + inline void setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>::Builder initEntries(unsigned int size); + inline void adoptEntries(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>> disownEntries(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -10164,17 +8092,14 @@ class ArrayMetadata::Builder { #if !CAPNP_LITE class ArrayMetadata::Pipeline { - public: +public: typedef ArrayMetadata Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -10183,13 +8108,11 @@ class ArrayMetadata::Pipeline { #endif // !CAPNP_LITE class ArrayMetadata::MetadataEntry::Reader { - public: +public: typedef MetadataEntry Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -10202,19 +8125,19 @@ class ArrayMetadata::MetadataEntry::Reader { #endif // !CAPNP_LITE inline bool hasKey() const; - inline ::capnp::Text::Reader getKey() const; + inline ::capnp::Text::Reader getKey() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; - inline ::uint32_t getValueNum() const; + inline ::uint32_t getValueNum() const; inline bool hasValue() const; - inline ::capnp::Data::Reader getValue() const; + inline ::capnp::Data::Reader getValue() const; inline bool getDel() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -10227,60 +8150,49 @@ class ArrayMetadata::MetadataEntry::Reader { }; class ArrayMetadata::MetadataEntry::Builder { - public: +public: typedef MetadataEntry Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasKey(); - inline ::capnp::Text::Builder getKey(); - inline void setKey(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initKey(unsigned int size); - inline void adoptKey(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownKey(); + inline ::capnp::Text::Builder getKey(); + inline void setKey( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initKey(unsigned int size); + inline void adoptKey(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownKey(); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownType(); - inline ::uint32_t getValueNum(); - inline void setValueNum(::uint32_t value); + inline ::uint32_t getValueNum(); + inline void setValueNum( ::uint32_t value); inline bool hasValue(); - inline ::capnp::Data::Builder getValue(); - inline void setValue(::capnp::Data::Reader value); - inline ::capnp::Data::Builder initValue(unsigned int size); - inline void adoptValue(::capnp::Orphan<::capnp::Data>&& value); - inline ::capnp::Orphan<::capnp::Data> disownValue(); + inline ::capnp::Data::Builder getValue(); + inline void setValue( ::capnp::Data::Reader value); + inline ::capnp::Data::Builder initValue(unsigned int size); + inline void adoptValue(::capnp::Orphan< ::capnp::Data>&& value); + inline ::capnp::Orphan< ::capnp::Data> disownValue(); inline bool getDel(); inline void setDel(bool value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -10291,17 +8203,14 @@ class ArrayMetadata::MetadataEntry::Builder { #if !CAPNP_LITE class ArrayMetadata::MetadataEntry::Pipeline { - public: +public: typedef MetadataEntry Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -10310,13 +8219,11 @@ class ArrayMetadata::MetadataEntry::Pipeline { #endif // !CAPNP_LITE class ArrayDirectory::Reader { - public: +public: typedef ArrayDirectory Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -10329,62 +8236,46 @@ class ArrayDirectory::Reader { #endif // !CAPNP_LITE inline bool hasUnfilteredFragmentUris() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getUnfilteredFragmentUris() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getUnfilteredFragmentUris() const; inline bool hasConsolidatedCommitUris() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getConsolidatedCommitUris() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getConsolidatedCommitUris() const; inline bool hasArraySchemaUris() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getArraySchemaUris() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getArraySchemaUris() const; inline bool hasLatestArraySchemaUri() const; - inline ::capnp::Text::Reader getLatestArraySchemaUri() const; + inline ::capnp::Text::Reader getLatestArraySchemaUri() const; inline bool hasArrayMetaUrisToVacuum() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getArrayMetaUrisToVacuum() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getArrayMetaUrisToVacuum() const; inline bool hasArrayMetaVacUrisToVacuum() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getArrayMetaVacUrisToVacuum() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getArrayMetaVacUrisToVacuum() const; inline bool hasCommitUrisToConsolidate() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getCommitUrisToConsolidate() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getCommitUrisToConsolidate() const; inline bool hasCommitUrisToVacuum() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getCommitUrisToVacuum() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getCommitUrisToVacuum() const; inline bool hasConsolidatedCommitUrisToVacuum() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getConsolidatedCommitUrisToVacuum() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getConsolidatedCommitUrisToVacuum() const; inline bool hasArrayMetaUris() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>::Reader - getArrayMetaUris() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>::Reader getArrayMetaUris() const; inline bool hasFragmentMetaUris() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getFragmentMetaUris() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getFragmentMetaUris() const; inline bool hasDeleteAndUpdateTileLocation() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>::Reader - getDeleteAndUpdateTileLocation() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>::Reader getDeleteAndUpdateTileLocation() const; - inline ::uint64_t getTimestampStart() const; + inline ::uint64_t getTimestampStart() const; - inline ::uint64_t getTimestampEnd() const; + inline ::uint64_t getTimestampEnd() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -10397,230 +8288,121 @@ class ArrayDirectory::Reader { }; class ArrayDirectory::Builder { - public: +public: typedef ArrayDirectory Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasUnfilteredFragmentUris(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getUnfilteredFragmentUris(); - inline void setUnfilteredFragmentUris( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setUnfilteredFragmentUris( - ::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initUnfilteredFragmentUris(unsigned int size); - inline void adoptUnfilteredFragmentUris( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownUnfilteredFragmentUris(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getUnfilteredFragmentUris(); + inline void setUnfilteredFragmentUris( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setUnfilteredFragmentUris(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initUnfilteredFragmentUris(unsigned int size); + inline void adoptUnfilteredFragmentUris(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownUnfilteredFragmentUris(); inline bool hasConsolidatedCommitUris(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getConsolidatedCommitUris(); - inline void setConsolidatedCommitUris( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setConsolidatedCommitUris( - ::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initConsolidatedCommitUris(unsigned int size); - inline void adoptConsolidatedCommitUris( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownConsolidatedCommitUris(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getConsolidatedCommitUris(); + inline void setConsolidatedCommitUris( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setConsolidatedCommitUris(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initConsolidatedCommitUris(unsigned int size); + inline void adoptConsolidatedCommitUris(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownConsolidatedCommitUris(); inline bool hasArraySchemaUris(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getArraySchemaUris(); - inline void setArraySchemaUris( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setArraySchemaUris( - ::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initArraySchemaUris(unsigned int size); - inline void adoptArraySchemaUris( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownArraySchemaUris(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getArraySchemaUris(); + inline void setArraySchemaUris( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setArraySchemaUris(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initArraySchemaUris(unsigned int size); + inline void adoptArraySchemaUris(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownArraySchemaUris(); inline bool hasLatestArraySchemaUri(); - inline ::capnp::Text::Builder getLatestArraySchemaUri(); - inline void setLatestArraySchemaUri(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initLatestArraySchemaUri(unsigned int size); - inline void adoptLatestArraySchemaUri(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownLatestArraySchemaUri(); + inline ::capnp::Text::Builder getLatestArraySchemaUri(); + inline void setLatestArraySchemaUri( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initLatestArraySchemaUri(unsigned int size); + inline void adoptLatestArraySchemaUri(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownLatestArraySchemaUri(); inline bool hasArrayMetaUrisToVacuum(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getArrayMetaUrisToVacuum(); - inline void setArrayMetaUrisToVacuum( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setArrayMetaUrisToVacuum( - ::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initArrayMetaUrisToVacuum(unsigned int size); - inline void adoptArrayMetaUrisToVacuum( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownArrayMetaUrisToVacuum(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getArrayMetaUrisToVacuum(); + inline void setArrayMetaUrisToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setArrayMetaUrisToVacuum(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initArrayMetaUrisToVacuum(unsigned int size); + inline void adoptArrayMetaUrisToVacuum(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownArrayMetaUrisToVacuum(); inline bool hasArrayMetaVacUrisToVacuum(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getArrayMetaVacUrisToVacuum(); - inline void setArrayMetaVacUrisToVacuum( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setArrayMetaVacUrisToVacuum( - ::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initArrayMetaVacUrisToVacuum(unsigned int size); - inline void adoptArrayMetaVacUrisToVacuum( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownArrayMetaVacUrisToVacuum(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getArrayMetaVacUrisToVacuum(); + inline void setArrayMetaVacUrisToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setArrayMetaVacUrisToVacuum(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initArrayMetaVacUrisToVacuum(unsigned int size); + inline void adoptArrayMetaVacUrisToVacuum(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownArrayMetaVacUrisToVacuum(); inline bool hasCommitUrisToConsolidate(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getCommitUrisToConsolidate(); - inline void setCommitUrisToConsolidate( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setCommitUrisToConsolidate( - ::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initCommitUrisToConsolidate(unsigned int size); - inline void adoptCommitUrisToConsolidate( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownCommitUrisToConsolidate(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getCommitUrisToConsolidate(); + inline void setCommitUrisToConsolidate( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setCommitUrisToConsolidate(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initCommitUrisToConsolidate(unsigned int size); + inline void adoptCommitUrisToConsolidate(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownCommitUrisToConsolidate(); inline bool hasCommitUrisToVacuum(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getCommitUrisToVacuum(); - inline void setCommitUrisToVacuum( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setCommitUrisToVacuum( - ::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initCommitUrisToVacuum(unsigned int size); - inline void adoptCommitUrisToVacuum( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownCommitUrisToVacuum(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getCommitUrisToVacuum(); + inline void setCommitUrisToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setCommitUrisToVacuum(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initCommitUrisToVacuum(unsigned int size); + inline void adoptCommitUrisToVacuum(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownCommitUrisToVacuum(); inline bool hasConsolidatedCommitUrisToVacuum(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getConsolidatedCommitUrisToVacuum(); - inline void setConsolidatedCommitUrisToVacuum( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setConsolidatedCommitUrisToVacuum( - ::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initConsolidatedCommitUrisToVacuum(unsigned int size); - inline void adoptConsolidatedCommitUrisToVacuum( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownConsolidatedCommitUrisToVacuum(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getConsolidatedCommitUrisToVacuum(); + inline void setConsolidatedCommitUrisToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setConsolidatedCommitUrisToVacuum(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initConsolidatedCommitUrisToVacuum(unsigned int size); + inline void adoptConsolidatedCommitUrisToVacuum(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownConsolidatedCommitUrisToVacuum(); inline bool hasArrayMetaUris(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>::Builder - getArrayMetaUris(); - inline void setArrayMetaUris( - ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>::Builder - initArrayMetaUris(unsigned int size); - inline void adoptArrayMetaUris( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>> - disownArrayMetaUris(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>::Builder getArrayMetaUris(); + inline void setArrayMetaUris( ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>::Builder initArrayMetaUris(unsigned int size); + inline void adoptArrayMetaUris(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>> disownArrayMetaUris(); inline bool hasFragmentMetaUris(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getFragmentMetaUris(); - inline void setFragmentMetaUris( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setFragmentMetaUris( - ::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initFragmentMetaUris(unsigned int size); - inline void adoptFragmentMetaUris( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownFragmentMetaUris(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getFragmentMetaUris(); + inline void setFragmentMetaUris( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setFragmentMetaUris(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initFragmentMetaUris(unsigned int size); + inline void adoptFragmentMetaUris(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownFragmentMetaUris(); inline bool hasDeleteAndUpdateTileLocation(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>::Builder - getDeleteAndUpdateTileLocation(); - inline void setDeleteAndUpdateTileLocation( - ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>::Builder - initDeleteAndUpdateTileLocation(unsigned int size); - inline void adoptDeleteAndUpdateTileLocation( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>> - disownDeleteAndUpdateTileLocation(); - - inline ::uint64_t getTimestampStart(); - inline void setTimestampStart(::uint64_t value); - - inline ::uint64_t getTimestampEnd(); - inline void setTimestampEnd(::uint64_t value); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>::Builder getDeleteAndUpdateTileLocation(); + inline void setDeleteAndUpdateTileLocation( ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>::Builder initDeleteAndUpdateTileLocation(unsigned int size); + inline void adoptDeleteAndUpdateTileLocation(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>> disownDeleteAndUpdateTileLocation(); + + inline ::uint64_t getTimestampStart(); + inline void setTimestampStart( ::uint64_t value); + + inline ::uint64_t getTimestampEnd(); + inline void setTimestampEnd( ::uint64_t value); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -10631,17 +8413,14 @@ class ArrayDirectory::Builder { #if !CAPNP_LITE class ArrayDirectory::Pipeline { - public: +public: typedef ArrayDirectory Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -10650,13 +8429,11 @@ class ArrayDirectory::Pipeline { #endif // !CAPNP_LITE class ArrayDirectory::TimestampedURI::Reader { - public: +public: typedef TimestampedURI Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -10669,13 +8446,13 @@ class ArrayDirectory::TimestampedURI::Reader { #endif // !CAPNP_LITE inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; - inline ::uint64_t getTimestampStart() const; + inline ::uint64_t getTimestampStart() const; - inline ::uint64_t getTimestampEnd() const; + inline ::uint64_t getTimestampEnd() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -10688,46 +8465,35 @@ class ArrayDirectory::TimestampedURI::Reader { }; class ArrayDirectory::TimestampedURI::Builder { - public: +public: typedef TimestampedURI Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownUri(); - inline ::uint64_t getTimestampStart(); - inline void setTimestampStart(::uint64_t value); + inline ::uint64_t getTimestampStart(); + inline void setTimestampStart( ::uint64_t value); - inline ::uint64_t getTimestampEnd(); - inline void setTimestampEnd(::uint64_t value); + inline ::uint64_t getTimestampEnd(); + inline void setTimestampEnd( ::uint64_t value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -10738,17 +8504,14 @@ class ArrayDirectory::TimestampedURI::Builder { #if !CAPNP_LITE class ArrayDirectory::TimestampedURI::Pipeline { - public: +public: typedef TimestampedURI Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -10757,13 +8520,11 @@ class ArrayDirectory::TimestampedURI::Pipeline { #endif // !CAPNP_LITE class ArrayDirectory::DeleteAndUpdateTileLocation::Reader { - public: +public: typedef DeleteAndUpdateTileLocation Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -10776,14 +8537,14 @@ class ArrayDirectory::DeleteAndUpdateTileLocation::Reader { #endif // !CAPNP_LITE inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; inline bool hasConditionMarker() const; - inline ::capnp::Text::Reader getConditionMarker() const; + inline ::capnp::Text::Reader getConditionMarker() const; - inline ::uint64_t getOffset() const; + inline ::uint64_t getOffset() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -10796,50 +8557,39 @@ class ArrayDirectory::DeleteAndUpdateTileLocation::Reader { }; class ArrayDirectory::DeleteAndUpdateTileLocation::Builder { - public: +public: typedef DeleteAndUpdateTileLocation Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownUri(); inline bool hasConditionMarker(); - inline ::capnp::Text::Builder getConditionMarker(); - inline void setConditionMarker(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initConditionMarker(unsigned int size); - inline void adoptConditionMarker(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownConditionMarker(); + inline ::capnp::Text::Builder getConditionMarker(); + inline void setConditionMarker( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initConditionMarker(unsigned int size); + inline void adoptConditionMarker(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownConditionMarker(); - inline ::uint64_t getOffset(); - inline void setOffset(::uint64_t value); + inline ::uint64_t getOffset(); + inline void setOffset( ::uint64_t value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -10850,17 +8600,14 @@ class ArrayDirectory::DeleteAndUpdateTileLocation::Builder { #if !CAPNP_LITE class ArrayDirectory::DeleteAndUpdateTileLocation::Pipeline { - public: +public: typedef DeleteAndUpdateTileLocation Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -10869,13 +8616,11 @@ class ArrayDirectory::DeleteAndUpdateTileLocation::Pipeline { #endif // !CAPNP_LITE class EstimatedResultSize::Reader { - public: +public: typedef EstimatedResultSize Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -10888,20 +8633,12 @@ class EstimatedResultSize::Reader { #endif // !CAPNP_LITE inline bool hasResultSizes() const; - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: - Reader - getResultSizes() const; + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Reader getResultSizes() const; inline bool hasMemorySizes() const; - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: - Reader - getMemorySizes() const; + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Reader getMemorySizes() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -10914,85 +8651,36 @@ class EstimatedResultSize::Reader { }; class EstimatedResultSize::Builder { - public: +public: typedef EstimatedResultSize Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasResultSizes(); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: - Builder - getResultSizes(); - inline void setResultSizes( - ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: - Reader value); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: - Builder - initResultSizes(); - inline void adoptResultSizes( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize:: - ResultSize>>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>> - disownResultSizes(); + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Builder getResultSizes(); + inline void setResultSizes( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Reader value); + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Builder initResultSizes(); + inline void adoptResultSizes(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>> disownResultSizes(); inline bool hasMemorySizes(); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: - Builder - getMemorySizes(); - inline void setMemorySizes( - ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: - Reader value); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: - Builder - initMemorySizes(); - inline void adoptMemorySizes( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize:: - MemorySize>>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>> - disownMemorySizes(); - - private: + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Builder getMemorySizes(); + inline void setMemorySizes( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Reader value); + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Builder initMemorySizes(); + inline void adoptMemorySizes(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>> disownMemorySizes(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11003,28 +8691,16 @@ class EstimatedResultSize::Builder { #if !CAPNP_LITE class EstimatedResultSize::Pipeline { - public: +public: typedef EstimatedResultSize Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: - Pipeline - getResultSizes(); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: - Pipeline - getMemorySizes(); - - private: + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Pipeline getResultSizes(); + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Pipeline getMemorySizes(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11033,13 +8709,11 @@ class EstimatedResultSize::Pipeline { #endif // !CAPNP_LITE class EstimatedResultSize::ResultSize::Reader { - public: +public: typedef ResultSize Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11057,7 +8731,7 @@ class EstimatedResultSize::ResultSize::Reader { inline double getSizeValidity() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11070,30 +8744,19 @@ class EstimatedResultSize::ResultSize::Reader { }; class EstimatedResultSize::ResultSize::Builder { - public: +public: typedef ResultSize Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline double getSizeFixed(); @@ -11105,7 +8768,7 @@ class EstimatedResultSize::ResultSize::Builder { inline double getSizeValidity(); inline void setSizeValidity(double value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11116,17 +8779,14 @@ class EstimatedResultSize::ResultSize::Builder { #if !CAPNP_LITE class EstimatedResultSize::ResultSize::Pipeline { - public: +public: typedef ResultSize Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11135,13 +8795,11 @@ class EstimatedResultSize::ResultSize::Pipeline { #endif // !CAPNP_LITE class EstimatedResultSize::MemorySize::Reader { - public: +public: typedef MemorySize Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11153,13 +8811,13 @@ class EstimatedResultSize::MemorySize::Reader { } #endif // !CAPNP_LITE - inline ::uint64_t getSizeFixed() const; + inline ::uint64_t getSizeFixed() const; - inline ::uint64_t getSizeVar() const; + inline ::uint64_t getSizeVar() const; - inline ::uint64_t getSizeValidity() const; + inline ::uint64_t getSizeValidity() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11172,42 +8830,31 @@ class EstimatedResultSize::MemorySize::Reader { }; class EstimatedResultSize::MemorySize::Builder { - public: +public: typedef MemorySize Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE - inline ::uint64_t getSizeFixed(); - inline void setSizeFixed(::uint64_t value); + inline ::uint64_t getSizeFixed(); + inline void setSizeFixed( ::uint64_t value); - inline ::uint64_t getSizeVar(); - inline void setSizeVar(::uint64_t value); + inline ::uint64_t getSizeVar(); + inline void setSizeVar( ::uint64_t value); - inline ::uint64_t getSizeValidity(); - inline void setSizeValidity(::uint64_t value); + inline ::uint64_t getSizeValidity(); + inline void setSizeValidity( ::uint64_t value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11218,17 +8865,14 @@ class EstimatedResultSize::MemorySize::Builder { #if !CAPNP_LITE class EstimatedResultSize::MemorySize::Pipeline { - public: +public: typedef MemorySize Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11237,13 +8881,11 @@ class EstimatedResultSize::MemorySize::Pipeline { #endif // !CAPNP_LITE class FragmentInfoRequest::Reader { - public: +public: typedef FragmentInfoRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11256,9 +8898,9 @@ class FragmentInfoRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11271,43 +8913,29 @@ class FragmentInfoRequest::Reader { }; class FragmentInfoRequest::Builder { - public: +public: typedef FragmentInfoRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> - disownConfig(); - - private: + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11318,19 +8946,15 @@ class FragmentInfoRequest::Builder { #if !CAPNP_LITE class FragmentInfoRequest::Pipeline { - public: +public: typedef FragmentInfoRequest Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11339,13 +8963,11 @@ class FragmentInfoRequest::Pipeline { #endif // !CAPNP_LITE class SingleFragmentInfo::Reader { - public: +public: typedef SingleFragmentInfo Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11358,15 +8980,14 @@ class SingleFragmentInfo::Reader { #endif // !CAPNP_LITE inline bool hasArraySchemaName() const; - inline ::capnp::Text::Reader getArraySchemaName() const; + inline ::capnp::Text::Reader getArraySchemaName() const; inline bool hasMeta() const; - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader getMeta() - const; + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader getMeta() const; - inline ::uint64_t getFragmentSize() const; + inline ::uint64_t getFragmentSize() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11379,56 +9000,39 @@ class SingleFragmentInfo::Reader { }; class SingleFragmentInfo::Builder { - public: +public: typedef SingleFragmentInfo Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasArraySchemaName(); - inline ::capnp::Text::Builder getArraySchemaName(); - inline void setArraySchemaName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initArraySchemaName(unsigned int size); - inline void adoptArraySchemaName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownArraySchemaName(); + inline ::capnp::Text::Builder getArraySchemaName(); + inline void setArraySchemaName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initArraySchemaName(unsigned int size); + inline void adoptArraySchemaName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownArraySchemaName(); inline bool hasMeta(); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder - getMeta(); - inline void setMeta( - ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder - initMeta(); - inline void adoptMeta( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata> - disownMeta(); - - inline ::uint64_t getFragmentSize(); - inline void setFragmentSize(::uint64_t value); - - private: + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder getMeta(); + inline void setMeta( ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value); + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder initMeta(); + inline void adoptMeta(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata> disownMeta(); + + inline ::uint64_t getFragmentSize(); + inline void setFragmentSize( ::uint64_t value); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11439,20 +9043,15 @@ class SingleFragmentInfo::Builder { #if !CAPNP_LITE class SingleFragmentInfo::Pipeline { - public: +public: typedef SingleFragmentInfo Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline - getMeta(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline getMeta(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11461,13 +9060,11 @@ class SingleFragmentInfo::Pipeline { #endif // !CAPNP_LITE class FragmentInfo::Reader { - public: +public: typedef FragmentInfo Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11480,26 +9077,18 @@ class FragmentInfo::Reader { #endif // !CAPNP_LITE inline bool hasArraySchemaLatest() const; - inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader - getArraySchemaLatest() const; + inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader getArraySchemaLatest() const; inline bool hasArraySchemasAll() const; - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Reader - getArraySchemasAll() const; + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader getArraySchemasAll() const; inline bool hasFragmentInfo() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>::Reader - getFragmentInfo() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>::Reader getFragmentInfo() const; inline bool hasToVacuum() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader getToVacuum() - const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getToVacuum() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11512,103 +9101,51 @@ class FragmentInfo::Reader { }; class FragmentInfo::Builder { - public: +public: typedef FragmentInfo Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasArraySchemaLatest(); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder - getArraySchemaLatest(); - inline void setArraySchemaLatest( - ::tiledb::sm::serialization::capnp::ArraySchema::Reader value); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder - initArraySchemaLatest(); - inline void adoptArraySchemaLatest( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema> - disownArraySchemaLatest(); + inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder getArraySchemaLatest(); + inline void setArraySchemaLatest( ::tiledb::sm::serialization::capnp::ArraySchema::Reader value); + inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder initArraySchemaLatest(); + inline void adoptArraySchemaLatest(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema> disownArraySchemaLatest(); inline bool hasArraySchemasAll(); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Builder - getArraySchemasAll(); - inline void setArraySchemasAll( - ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Builder - initArraySchemasAll(); - inline void adoptArraySchemasAll( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>> - disownArraySchemasAll(); + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder getArraySchemasAll(); + inline void setArraySchemasAll( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value); + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder initArraySchemasAll(); + inline void adoptArraySchemasAll(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>> disownArraySchemasAll(); inline bool hasFragmentInfo(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>::Builder - getFragmentInfo(); - inline void setFragmentInfo( - ::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>::Builder - initFragmentInfo(unsigned int size); - inline void adoptFragmentInfo( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>> - disownFragmentInfo(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>::Builder getFragmentInfo(); + inline void setFragmentInfo( ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>::Builder initFragmentInfo(unsigned int size); + inline void adoptFragmentInfo(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>> disownFragmentInfo(); inline bool hasToVacuum(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getToVacuum(); - inline void setToVacuum( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setToVacuum(::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initToVacuum(unsigned int size); - inline void adoptToVacuum( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownToVacuum(); - - private: + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getToVacuum(); + inline void setToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setToVacuum(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initToVacuum(unsigned int size); + inline void adoptToVacuum(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownToVacuum(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11619,24 +9156,16 @@ class FragmentInfo::Builder { #if !CAPNP_LITE class FragmentInfo::Pipeline { - public: +public: typedef FragmentInfo Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline - getArraySchemaLatest(); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline - getArraySchemasAll(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline getArraySchemaLatest(); + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline getArraySchemasAll(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11645,13 +9174,11 @@ class FragmentInfo::Pipeline { #endif // !CAPNP_LITE class GroupMetadata::Reader { - public: +public: typedef GroupMetadata Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11664,13 +9191,12 @@ class GroupMetadata::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasMetadata() const; - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader getMetadata() - const; + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader getMetadata() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11683,56 +9209,36 @@ class GroupMetadata::Reader { }; class GroupMetadata::Builder { - public: +public: typedef GroupMetadata Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> - disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); inline bool hasMetadata(); - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder - getMetadata(); - inline void setMetadata( - ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value); - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder - initMetadata(); - inline void adoptMetadata( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata> - disownMetadata(); - - private: + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder getMetadata(); + inline void setMetadata( ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value); + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder initMetadata(); + inline void adoptMetadata(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata> disownMetadata(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11743,21 +9249,16 @@ class GroupMetadata::Builder { #if !CAPNP_LITE class GroupMetadata::Pipeline { - public: +public: typedef GroupMetadata Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline - getMetadata(); - - private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline getMetadata(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11766,13 +9267,11 @@ class GroupMetadata::Pipeline { #endif // !CAPNP_LITE class GroupMember::Reader { - public: +public: typedef GroupMember Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11785,17 +9284,17 @@ class GroupMember::Reader { #endif // !CAPNP_LITE inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; inline bool getRelative() const; inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11808,57 +9307,46 @@ class GroupMember::Reader { }; class GroupMember::Builder { - public: +public: typedef GroupMember Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownUri(); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownType(); inline bool getRelative(); inline void setRelative(bool value); inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownName(); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11869,17 +9357,14 @@ class GroupMember::Builder { #if !CAPNP_LITE class GroupMember::Pipeline { - public: +public: typedef GroupMember Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11888,13 +9373,11 @@ class GroupMember::Pipeline { #endif // !CAPNP_LITE class Group::Reader { - public: +public: typedef Group Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11907,13 +9390,12 @@ class Group::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasGroup() const; - inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Reader - getGroup() const; + inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Reader getGroup() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11926,57 +9408,36 @@ class Group::Reader { }; class Group::Builder { - public: +public: typedef Group Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> - disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); inline bool hasGroup(); - inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Builder - getGroup(); - inline void setGroup( - ::tiledb::sm::serialization::capnp::Group::GroupDetails::Reader value); - inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Builder - initGroup(); - inline void adoptGroup( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Group::GroupDetails>&& - value); - inline ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::Group::GroupDetails> - disownGroup(); - - private: + inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Builder getGroup(); + inline void setGroup( ::tiledb::sm::serialization::capnp::Group::GroupDetails::Reader value); + inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Builder initGroup(); + inline void adoptGroup(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Group::GroupDetails>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Group::GroupDetails> disownGroup(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11987,21 +9448,16 @@ class Group::Builder { #if !CAPNP_LITE class Group::Pipeline { - public: +public: typedef Group Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Pipeline - getGroup(); - - private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Pipeline getGroup(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -12010,13 +9466,11 @@ class Group::Pipeline { #endif // !CAPNP_LITE class Group::GroupDetails::Reader { - public: +public: typedef GroupDetails Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -12029,16 +9483,12 @@ class Group::GroupDetails::Reader { #endif // !CAPNP_LITE inline bool hasMembers() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>::Reader - getMembers() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Reader getMembers() const; inline bool hasMetadata() const; - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader getMetadata() - const; + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader getMetadata() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -12051,66 +9501,36 @@ class Group::GroupDetails::Reader { }; class Group::GroupDetails::Builder { - public: +public: typedef GroupDetails Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasMembers(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>::Builder - getMembers(); - inline void setMembers(::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>::Builder - initMembers(unsigned int size); - inline void adoptMembers(::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>> - disownMembers(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Builder getMembers(); + inline void setMembers( ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Builder initMembers(unsigned int size); + inline void adoptMembers(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>> disownMembers(); inline bool hasMetadata(); - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder - getMetadata(); - inline void setMetadata( - ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value); - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder - initMetadata(); - inline void adoptMetadata( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata> - disownMetadata(); - - private: + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder getMetadata(); + inline void setMetadata( ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value); + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder initMetadata(); + inline void adoptMetadata(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata> disownMetadata(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -12121,20 +9541,15 @@ class Group::GroupDetails::Builder { #if !CAPNP_LITE class Group::GroupDetails::Pipeline { - public: +public: typedef GroupDetails Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline - getMetadata(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline getMetadata(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -12143,13 +9558,11 @@ class Group::GroupDetails::Pipeline { #endif // !CAPNP_LITE class GroupUpdate::Reader { - public: +public: typedef GroupUpdate Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -12162,14 +9575,12 @@ class GroupUpdate::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasGroupUpdate() const; - inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: - Reader - getGroupUpdate() const; + inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Reader getGroupUpdate() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -12182,60 +9593,36 @@ class GroupUpdate::Reader { }; class GroupUpdate::Builder { - public: +public: typedef GroupUpdate Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> - disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); inline bool hasGroupUpdate(); - inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: - Builder - getGroupUpdate(); - inline void setGroupUpdate(::tiledb::sm::serialization::capnp::GroupUpdate:: - GroupUpdateDetails::Reader value); - inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: - Builder - initGroupUpdate(); - inline void adoptGroupUpdate( - ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>&& - value); - inline ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails> - disownGroupUpdate(); - - private: + inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Builder getGroupUpdate(); + inline void setGroupUpdate( ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Reader value); + inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Builder initGroupUpdate(); + inline void adoptGroupUpdate(::capnp::Orphan< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails> disownGroupUpdate(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -12246,22 +9633,16 @@ class GroupUpdate::Builder { #if !CAPNP_LITE class GroupUpdate::Pipeline { - public: +public: typedef GroupUpdate Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: - Pipeline - getGroupUpdate(); - - private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Pipeline getGroupUpdate(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -12270,13 +9651,11 @@ class GroupUpdate::Pipeline { #endif // !CAPNP_LITE class GroupUpdate::GroupUpdateDetails::Reader { - public: +public: typedef GroupUpdateDetails Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -12289,16 +9668,12 @@ class GroupUpdate::GroupUpdateDetails::Reader { #endif // !CAPNP_LITE inline bool hasMembersToRemove() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getMembersToRemove() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getMembersToRemove() const; inline bool hasMembersToAdd() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>::Reader - getMembersToAdd() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Reader getMembersToAdd() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -12311,69 +9686,37 @@ class GroupUpdate::GroupUpdateDetails::Reader { }; class GroupUpdate::GroupUpdateDetails::Builder { - public: +public: typedef GroupUpdateDetails Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasMembersToRemove(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getMembersToRemove(); - inline void setMembersToRemove( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setMembersToRemove( - ::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initMembersToRemove(unsigned int size); - inline void adoptMembersToRemove( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownMembersToRemove(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getMembersToRemove(); + inline void setMembersToRemove( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setMembersToRemove(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initMembersToRemove(unsigned int size); + inline void adoptMembersToRemove(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownMembersToRemove(); inline bool hasMembersToAdd(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>::Builder - getMembersToAdd(); - inline void setMembersToAdd(::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>::Builder - initMembersToAdd(unsigned int size); - inline void adoptMembersToAdd( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>> - disownMembersToAdd(); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Builder getMembersToAdd(); + inline void setMembersToAdd( ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Builder initMembersToAdd(unsigned int size); + inline void adoptMembersToAdd(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>> disownMembersToAdd(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -12384,17 +9727,14 @@ class GroupUpdate::GroupUpdateDetails::Builder { #if !CAPNP_LITE class GroupUpdate::GroupUpdateDetails::Pipeline { - public: +public: typedef GroupUpdateDetails Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -12403,13 +9743,11 @@ class GroupUpdate::GroupUpdateDetails::Pipeline { #endif // !CAPNP_LITE class GroupCreate::Reader { - public: +public: typedef GroupCreate Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -12422,14 +9760,12 @@ class GroupCreate::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasGroupDetails() const; - inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: - Reader - getGroupDetails() const; + inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Reader getGroupDetails() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -12442,60 +9778,36 @@ class GroupCreate::Reader { }; class GroupCreate::Builder { - public: +public: typedef GroupCreate Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> - disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); inline bool hasGroupDetails(); - inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: - Builder - getGroupDetails(); - inline void setGroupDetails(::tiledb::sm::serialization::capnp::GroupCreate:: - GroupCreateDetails::Reader value); - inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: - Builder - initGroupDetails(); - inline void adoptGroupDetails( - ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>&& - value); - inline ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails> - disownGroupDetails(); - - private: + inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Builder getGroupDetails(); + inline void setGroupDetails( ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Reader value); + inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Builder initGroupDetails(); + inline void adoptGroupDetails(::capnp::Orphan< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails> disownGroupDetails(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -12506,22 +9818,16 @@ class GroupCreate::Builder { #if !CAPNP_LITE class GroupCreate::Pipeline { - public: +public: typedef GroupCreate Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: - Pipeline - getGroupDetails(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Pipeline getGroupDetails(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -12530,13 +9836,11 @@ class GroupCreate::Pipeline { #endif // !CAPNP_LITE class GroupCreate::GroupCreateDetails::Reader { - public: +public: typedef GroupCreateDetails Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -12549,9 +9853,9 @@ class GroupCreate::GroupCreateDetails::Reader { #endif // !CAPNP_LITE inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -12564,40 +9868,29 @@ class GroupCreate::GroupCreateDetails::Reader { }; class GroupCreate::GroupCreateDetails::Builder { - public: +public: typedef GroupCreateDetails Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownUri(); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -12608,17 +9901,14 @@ class GroupCreate::GroupCreateDetails::Builder { #if !CAPNP_LITE class GroupCreate::GroupCreateDetails::Pipeline { - public: +public: typedef GroupCreateDetails Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -12627,13 +9917,11 @@ class GroupCreate::GroupCreateDetails::Pipeline { #endif // !CAPNP_LITE class GlobalWriteState::Reader { - public: +public: typedef GlobalWriteState Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -12646,26 +9934,20 @@ class GlobalWriteState::Reader { #endif // !CAPNP_LITE inline bool hasCellsWritten() const; - inline ::tiledb::sm::serialization::capnp::MapUInt64::Reader getCellsWritten() - const; + inline ::tiledb::sm::serialization::capnp::MapUInt64::Reader getCellsWritten() const; inline bool hasFragMeta() const; - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader - getFragMeta() const; + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader getFragMeta() const; inline bool hasLastCellCoords() const; - inline ::tiledb::sm::serialization::capnp::SingleCoord::Reader - getLastCellCoords() const; + inline ::tiledb::sm::serialization::capnp::SingleCoord::Reader getLastCellCoords() const; - inline ::uint64_t getLastHilbertValue() const; + inline ::uint64_t getLastHilbertValue() const; inline bool hasMultiPartUploadStates() const; - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Reader - getMultiPartUploadStates() const; + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Reader getMultiPartUploadStates() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -12678,96 +9960,53 @@ class GlobalWriteState::Reader { }; class GlobalWriteState::Builder { - public: +public: typedef GlobalWriteState Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasCellsWritten(); - inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder - getCellsWritten(); - inline void setCellsWritten( - ::tiledb::sm::serialization::capnp::MapUInt64::Reader value); - inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder - initCellsWritten(); - inline void adoptCellsWritten( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapUInt64>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapUInt64> - disownCellsWritten(); + inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder getCellsWritten(); + inline void setCellsWritten( ::tiledb::sm::serialization::capnp::MapUInt64::Reader value); + inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder initCellsWritten(); + inline void adoptCellsWritten(::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapUInt64>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapUInt64> disownCellsWritten(); inline bool hasFragMeta(); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder - getFragMeta(); - inline void setFragMeta( - ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder - initFragMeta(); - inline void adoptFragMeta( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata> - disownFragMeta(); + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder getFragMeta(); + inline void setFragMeta( ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value); + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder initFragMeta(); + inline void adoptFragMeta(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata> disownFragMeta(); inline bool hasLastCellCoords(); - inline ::tiledb::sm::serialization::capnp::SingleCoord::Builder - getLastCellCoords(); - inline void setLastCellCoords( - ::tiledb::sm::serialization::capnp::SingleCoord::Reader value); - inline ::tiledb::sm::serialization::capnp::SingleCoord::Builder - initLastCellCoords(); - inline void adoptLastCellCoords( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::SingleCoord>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::SingleCoord> - disownLastCellCoords(); - - inline ::uint64_t getLastHilbertValue(); - inline void setLastHilbertValue(::uint64_t value); + inline ::tiledb::sm::serialization::capnp::SingleCoord::Builder getLastCellCoords(); + inline void setLastCellCoords( ::tiledb::sm::serialization::capnp::SingleCoord::Reader value); + inline ::tiledb::sm::serialization::capnp::SingleCoord::Builder initLastCellCoords(); + inline void adoptLastCellCoords(::capnp::Orphan< ::tiledb::sm::serialization::capnp::SingleCoord>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SingleCoord> disownLastCellCoords(); + + inline ::uint64_t getLastHilbertValue(); + inline void setLastHilbertValue( ::uint64_t value); inline bool hasMultiPartUploadStates(); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Builder - getMultiPartUploadStates(); - inline void setMultiPartUploadStates( - ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Reader - value); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Builder - initMultiPartUploadStates(); - inline void adoptMultiPartUploadStates( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>> - disownMultiPartUploadStates(); - - private: + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Builder getMultiPartUploadStates(); + inline void setMultiPartUploadStates( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Reader value); + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Builder initMultiPartUploadStates(); + inline void adoptMultiPartUploadStates(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>> disownMultiPartUploadStates(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -12778,28 +10017,18 @@ class GlobalWriteState::Builder { #if !CAPNP_LITE class GlobalWriteState::Pipeline { - public: +public: typedef GlobalWriteState Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline - getCellsWritten(); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline - getFragMeta(); - inline ::tiledb::sm::serialization::capnp::SingleCoord::Pipeline - getLastCellCoords(); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Pipeline - getMultiPartUploadStates(); - - private: + inline ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline getCellsWritten(); + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline getFragMeta(); + inline ::tiledb::sm::serialization::capnp::SingleCoord::Pipeline getLastCellCoords(); + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Pipeline getMultiPartUploadStates(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -12808,13 +10037,11 @@ class GlobalWriteState::Pipeline { #endif // !CAPNP_LITE class SingleCoord::Reader { - public: +public: typedef SingleCoord Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -12827,20 +10054,15 @@ class SingleCoord::Reader { #endif // !CAPNP_LITE inline bool hasCoords() const; - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader - getCoords() const; + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getCoords() const; inline bool hasSizes() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getSizes() - const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getSizes() const; inline bool hasSingleOffset() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getSingleOffset() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getSingleOffset() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -12853,86 +10075,46 @@ class SingleCoord::Reader { }; class SingleCoord::Builder { - public: +public: typedef SingleCoord Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasCoords(); - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - getCoords(); - inline void setCoords(::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value); - inline void setCoords( - ::kj::ArrayPtr< - const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> - value); - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - initCoords(unsigned int size); - inline void adoptCoords( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> - disownCoords(); + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getCoords(); + inline void setCoords( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); + inline void setCoords(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initCoords(unsigned int size); + inline void adoptCoords(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownCoords(); inline bool hasSizes(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getSizes(); - inline void setSizes( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setSizes(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initSizes( - unsigned int size); - inline void adoptSizes( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownSizes(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getSizes(); + inline void setSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setSizes(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initSizes(unsigned int size); + inline void adoptSizes(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownSizes(); inline bool hasSingleOffset(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getSingleOffset(); - inline void setSingleOffset( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setSingleOffset(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initSingleOffset(unsigned int size); - inline void adoptSingleOffset( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownSingleOffset(); - - private: + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getSingleOffset(); + inline void setSingleOffset( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setSingleOffset(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initSingleOffset(unsigned int size); + inline void adoptSingleOffset(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownSingleOffset(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -12943,17 +10125,14 @@ class SingleCoord::Builder { #if !CAPNP_LITE class SingleCoord::Pipeline { - public: +public: typedef SingleCoord Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -12962,13 +10141,11 @@ class SingleCoord::Pipeline { #endif // !CAPNP_LITE class FragmentMetadata::Reader { - public: +public: typedef FragmentMetadata Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -12981,134 +10158,89 @@ class FragmentMetadata::Reader { #endif // !CAPNP_LITE inline bool hasFileSizes() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getFileSizes() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getFileSizes() const; inline bool hasFileVarSizes() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getFileVarSizes() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getFileVarSizes() const; inline bool hasFileValiditySizes() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getFileValiditySizes() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getFileValiditySizes() const; inline bool hasFragmentUri() const; - inline ::capnp::Text::Reader getFragmentUri() const; + inline ::capnp::Text::Reader getFragmentUri() const; inline bool getHasTimestamps() const; inline bool getHasDeleteMeta() const; - inline ::uint64_t getSparseTileNum() const; + inline ::uint64_t getSparseTileNum() const; - inline ::uint64_t getTileIndexBase() const; + inline ::uint64_t getTileIndexBase() const; inline bool hasTileOffsets() const; - inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader - getTileOffsets() const; + inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileOffsets() const; inline bool hasTileVarOffsets() const; - inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader - getTileVarOffsets() const; + inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileVarOffsets() const; inline bool hasTileVarSizes() const; - inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader - getTileVarSizes() const; + inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileVarSizes() const; inline bool hasTileValidityOffsets() const; - inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader - getTileValidityOffsets() const; + inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileValidityOffsets() const; inline bool hasTileMinBuffer() const; - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader - getTileMinBuffer() const; + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileMinBuffer() const; inline bool hasTileMinVarBuffer() const; - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader - getTileMinVarBuffer() const; + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileMinVarBuffer() const; inline bool hasTileMaxBuffer() const; - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader - getTileMaxBuffer() const; + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileMaxBuffer() const; inline bool hasTileMaxVarBuffer() const; - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader - getTileMaxVarBuffer() const; + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileMaxVarBuffer() const; inline bool hasTileSums() const; - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader - getTileSums() const; + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileSums() const; inline bool hasTileNullCounts() const; - inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader - getTileNullCounts() const; + inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileNullCounts() const; inline bool hasFragmentMins() const; - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader - getFragmentMins() const; + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getFragmentMins() const; inline bool hasFragmentMaxs() const; - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader - getFragmentMaxs() const; + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getFragmentMaxs() const; inline bool hasFragmentSums() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getFragmentSums() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getFragmentSums() const; inline bool hasFragmentNullCounts() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getFragmentNullCounts() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getFragmentNullCounts() const; - inline ::uint32_t getVersion() const; + inline ::uint32_t getVersion() const; inline bool hasTimestampRange() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getTimestampRange() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTimestampRange() const; - inline ::uint64_t getLastTileCellNum() const; + inline ::uint64_t getLastTileCellNum() const; inline bool hasNonEmptyDomain() const; - inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader - getNonEmptyDomain() const; + inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader getNonEmptyDomain() const; inline bool hasRtree() const; - inline ::capnp::Data::Reader getRtree() const; + inline ::capnp::Data::Reader getRtree() const; inline bool getHasConsolidatedFooter() const; inline bool hasGtOffsets() const; - inline ::tiledb::sm::serialization::capnp::FragmentMetadata:: - GenericTileOffsets::Reader - getGtOffsets() const; + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Reader getGtOffsets() const; inline bool hasArraySchemaName() const; - inline ::capnp::Text::Reader getArraySchemaName() const; + inline ::capnp::Text::Reader getArraySchemaName() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -13121,80 +10253,51 @@ class FragmentMetadata::Reader { }; class FragmentMetadata::Builder { - public: +public: typedef FragmentMetadata Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasFileSizes(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getFileSizes(); - inline void setFileSizes( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setFileSizes(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initFileSizes(unsigned int size); - inline void adoptFileSizes( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownFileSizes(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getFileSizes(); + inline void setFileSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setFileSizes(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initFileSizes(unsigned int size); + inline void adoptFileSizes(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownFileSizes(); inline bool hasFileVarSizes(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getFileVarSizes(); - inline void setFileVarSizes( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setFileVarSizes(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initFileVarSizes(unsigned int size); - inline void adoptFileVarSizes( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownFileVarSizes(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getFileVarSizes(); + inline void setFileVarSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setFileVarSizes(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initFileVarSizes(unsigned int size); + inline void adoptFileVarSizes(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownFileVarSizes(); inline bool hasFileValiditySizes(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getFileValiditySizes(); - inline void setFileValiditySizes( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setFileValiditySizes(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initFileValiditySizes(unsigned int size); - inline void adoptFileValiditySizes( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownFileValiditySizes(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getFileValiditySizes(); + inline void setFileValiditySizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setFileValiditySizes(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initFileValiditySizes(unsigned int size); + inline void adoptFileValiditySizes(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownFileValiditySizes(); inline bool hasFragmentUri(); - inline ::capnp::Text::Builder getFragmentUri(); - inline void setFragmentUri(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initFragmentUri(unsigned int size); - inline void adoptFragmentUri(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownFragmentUri(); + inline ::capnp::Text::Builder getFragmentUri(); + inline void setFragmentUri( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initFragmentUri(unsigned int size); + inline void adoptFragmentUri(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownFragmentUri(); inline bool getHasTimestamps(); inline void setHasTimestamps(bool value); @@ -13202,419 +10305,170 @@ class FragmentMetadata::Builder { inline bool getHasDeleteMeta(); inline void setHasDeleteMeta(bool value); - inline ::uint64_t getSparseTileNum(); - inline void setSparseTileNum(::uint64_t value); + inline ::uint64_t getSparseTileNum(); + inline void setSparseTileNum( ::uint64_t value); - inline ::uint64_t getTileIndexBase(); - inline void setTileIndexBase(::uint64_t value); + inline ::uint64_t getTileIndexBase(); + inline void setTileIndexBase( ::uint64_t value); inline bool hasTileOffsets(); - inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - getTileOffsets(); - inline void setTileOffsets( - ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value); - inline void setTileOffsets( - ::kj::ArrayPtr< - const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> - value); - inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - initTileOffsets(unsigned int size); - inline void adoptTileOffsets( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> - disownTileOffsets(); + inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileOffsets(); + inline void setTileOffsets( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); + inline void setTileOffsets(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileOffsets(unsigned int size); + inline void adoptTileOffsets(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileOffsets(); inline bool hasTileVarOffsets(); - inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - getTileVarOffsets(); - inline void setTileVarOffsets( - ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value); - inline void setTileVarOffsets( - ::kj::ArrayPtr< - const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> - value); - inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - initTileVarOffsets(unsigned int size); - inline void adoptTileVarOffsets( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> - disownTileVarOffsets(); + inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileVarOffsets(); + inline void setTileVarOffsets( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); + inline void setTileVarOffsets(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileVarOffsets(unsigned int size); + inline void adoptTileVarOffsets(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileVarOffsets(); inline bool hasTileVarSizes(); - inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - getTileVarSizes(); - inline void setTileVarSizes( - ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value); - inline void setTileVarSizes( - ::kj::ArrayPtr< - const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> - value); - inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - initTileVarSizes(unsigned int size); - inline void adoptTileVarSizes( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> - disownTileVarSizes(); + inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileVarSizes(); + inline void setTileVarSizes( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); + inline void setTileVarSizes(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileVarSizes(unsigned int size); + inline void adoptTileVarSizes(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileVarSizes(); inline bool hasTileValidityOffsets(); - inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - getTileValidityOffsets(); - inline void setTileValidityOffsets( - ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value); - inline void setTileValidityOffsets( - ::kj::ArrayPtr< - const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> - value); - inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - initTileValidityOffsets(unsigned int size); - inline void adoptTileValidityOffsets( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> - disownTileValidityOffsets(); + inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileValidityOffsets(); + inline void setTileValidityOffsets( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); + inline void setTileValidityOffsets(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileValidityOffsets(unsigned int size); + inline void adoptTileValidityOffsets(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileValidityOffsets(); inline bool hasTileMinBuffer(); - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - getTileMinBuffer(); - inline void setTileMinBuffer( - ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value); - inline void setTileMinBuffer( - ::kj::ArrayPtr< - const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> - value); - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - initTileMinBuffer(unsigned int size); - inline void adoptTileMinBuffer( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> - disownTileMinBuffer(); + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileMinBuffer(); + inline void setTileMinBuffer( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); + inline void setTileMinBuffer(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileMinBuffer(unsigned int size); + inline void adoptTileMinBuffer(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileMinBuffer(); inline bool hasTileMinVarBuffer(); - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - getTileMinVarBuffer(); - inline void setTileMinVarBuffer( - ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value); - inline void setTileMinVarBuffer( - ::kj::ArrayPtr< - const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> - value); - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - initTileMinVarBuffer(unsigned int size); - inline void adoptTileMinVarBuffer( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> - disownTileMinVarBuffer(); + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileMinVarBuffer(); + inline void setTileMinVarBuffer( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); + inline void setTileMinVarBuffer(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileMinVarBuffer(unsigned int size); + inline void adoptTileMinVarBuffer(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileMinVarBuffer(); inline bool hasTileMaxBuffer(); - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - getTileMaxBuffer(); - inline void setTileMaxBuffer( - ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value); - inline void setTileMaxBuffer( - ::kj::ArrayPtr< - const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> - value); - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - initTileMaxBuffer(unsigned int size); - inline void adoptTileMaxBuffer( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> - disownTileMaxBuffer(); + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileMaxBuffer(); + inline void setTileMaxBuffer( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); + inline void setTileMaxBuffer(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileMaxBuffer(unsigned int size); + inline void adoptTileMaxBuffer(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileMaxBuffer(); inline bool hasTileMaxVarBuffer(); - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - getTileMaxVarBuffer(); - inline void setTileMaxVarBuffer( - ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value); - inline void setTileMaxVarBuffer( - ::kj::ArrayPtr< - const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> - value); - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - initTileMaxVarBuffer(unsigned int size); - inline void adoptTileMaxVarBuffer( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> - disownTileMaxVarBuffer(); + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileMaxVarBuffer(); + inline void setTileMaxVarBuffer( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); + inline void setTileMaxVarBuffer(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileMaxVarBuffer(unsigned int size); + inline void adoptTileMaxVarBuffer(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileMaxVarBuffer(); inline bool hasTileSums(); - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - getTileSums(); - inline void setTileSums(::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value); - inline void setTileSums( - ::kj::ArrayPtr< - const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> - value); - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - initTileSums(unsigned int size); - inline void adoptTileSums( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> - disownTileSums(); + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileSums(); + inline void setTileSums( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); + inline void setTileSums(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileSums(unsigned int size); + inline void adoptTileSums(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileSums(); inline bool hasTileNullCounts(); - inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - getTileNullCounts(); - inline void setTileNullCounts( - ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value); - inline void setTileNullCounts( - ::kj::ArrayPtr< - const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> - value); - inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - initTileNullCounts(unsigned int size); - inline void adoptTileNullCounts( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> - disownTileNullCounts(); + inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileNullCounts(); + inline void setTileNullCounts( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); + inline void setTileNullCounts(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileNullCounts(unsigned int size); + inline void adoptTileNullCounts(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileNullCounts(); inline bool hasFragmentMins(); - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - getFragmentMins(); - inline void setFragmentMins( - ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value); - inline void setFragmentMins( - ::kj::ArrayPtr< - const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> - value); - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - initFragmentMins(unsigned int size); - inline void adoptFragmentMins( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> - disownFragmentMins(); + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getFragmentMins(); + inline void setFragmentMins( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); + inline void setFragmentMins(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initFragmentMins(unsigned int size); + inline void adoptFragmentMins(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownFragmentMins(); inline bool hasFragmentMaxs(); - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - getFragmentMaxs(); - inline void setFragmentMaxs( - ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value); - inline void setFragmentMaxs( - ::kj::ArrayPtr< - const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> - value); - inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder - initFragmentMaxs(unsigned int size); - inline void adoptFragmentMaxs( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> - disownFragmentMaxs(); + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getFragmentMaxs(); + inline void setFragmentMaxs( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); + inline void setFragmentMaxs(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initFragmentMaxs(unsigned int size); + inline void adoptFragmentMaxs(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownFragmentMaxs(); inline bool hasFragmentSums(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getFragmentSums(); - inline void setFragmentSums( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setFragmentSums(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initFragmentSums(unsigned int size); - inline void adoptFragmentSums( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownFragmentSums(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getFragmentSums(); + inline void setFragmentSums( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setFragmentSums(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initFragmentSums(unsigned int size); + inline void adoptFragmentSums(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownFragmentSums(); inline bool hasFragmentNullCounts(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getFragmentNullCounts(); - inline void setFragmentNullCounts( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setFragmentNullCounts(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initFragmentNullCounts(unsigned int size); - inline void adoptFragmentNullCounts( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownFragmentNullCounts(); - - inline ::uint32_t getVersion(); - inline void setVersion(::uint32_t value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getFragmentNullCounts(); + inline void setFragmentNullCounts( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setFragmentNullCounts(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initFragmentNullCounts(unsigned int size); + inline void adoptFragmentNullCounts(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownFragmentNullCounts(); + + inline ::uint32_t getVersion(); + inline void setVersion( ::uint32_t value); inline bool hasTimestampRange(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getTimestampRange(); - inline void setTimestampRange( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTimestampRange(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initTimestampRange(unsigned int size); - inline void adoptTimestampRange( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownTimestampRange(); - - inline ::uint64_t getLastTileCellNum(); - inline void setLastTileCellNum(::uint64_t value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTimestampRange(); + inline void setTimestampRange( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTimestampRange(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTimestampRange(unsigned int size); + inline void adoptTimestampRange(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTimestampRange(); + + inline ::uint64_t getLastTileCellNum(); + inline void setLastTileCellNum( ::uint64_t value); inline bool hasNonEmptyDomain(); - inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder - getNonEmptyDomain(); - inline void setNonEmptyDomain( - ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader value); - inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder - initNonEmptyDomain(); - inline void adoptNonEmptyDomain( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::NonEmptyDomainList>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::NonEmptyDomainList> - disownNonEmptyDomain(); + inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder getNonEmptyDomain(); + inline void setNonEmptyDomain( ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader value); + inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder initNonEmptyDomain(); + inline void adoptNonEmptyDomain(::capnp::Orphan< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NonEmptyDomainList> disownNonEmptyDomain(); inline bool hasRtree(); - inline ::capnp::Data::Builder getRtree(); - inline void setRtree(::capnp::Data::Reader value); - inline ::capnp::Data::Builder initRtree(unsigned int size); - inline void adoptRtree(::capnp::Orphan<::capnp::Data>&& value); - inline ::capnp::Orphan<::capnp::Data> disownRtree(); + inline ::capnp::Data::Builder getRtree(); + inline void setRtree( ::capnp::Data::Reader value); + inline ::capnp::Data::Builder initRtree(unsigned int size); + inline void adoptRtree(::capnp::Orphan< ::capnp::Data>&& value); + inline ::capnp::Orphan< ::capnp::Data> disownRtree(); inline bool getHasConsolidatedFooter(); inline void setHasConsolidatedFooter(bool value); inline bool hasGtOffsets(); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata:: - GenericTileOffsets::Builder - getGtOffsets(); - inline void setGtOffsets( - ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets:: - Reader value); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata:: - GenericTileOffsets::Builder - initGtOffsets(); - inline void adoptGtOffsets( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata:: - GenericTileOffsets>&& value); - inline ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets> - disownGtOffsets(); + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Builder getGtOffsets(); + inline void setGtOffsets( ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Reader value); + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Builder initGtOffsets(); + inline void adoptGtOffsets(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets> disownGtOffsets(); inline bool hasArraySchemaName(); - inline ::capnp::Text::Builder getArraySchemaName(); - inline void setArraySchemaName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initArraySchemaName(unsigned int size); - inline void adoptArraySchemaName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownArraySchemaName(); + inline ::capnp::Text::Builder getArraySchemaName(); + inline void setArraySchemaName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initArraySchemaName(unsigned int size); + inline void adoptArraySchemaName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownArraySchemaName(); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -13625,23 +10479,16 @@ class FragmentMetadata::Builder { #if !CAPNP_LITE class FragmentMetadata::Pipeline { - public: +public: typedef FragmentMetadata Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline - getNonEmptyDomain(); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata:: - GenericTileOffsets::Pipeline - getGtOffsets(); - - private: + inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline getNonEmptyDomain(); + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Pipeline getGtOffsets(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -13650,13 +10497,11 @@ class FragmentMetadata::Pipeline { #endif // !CAPNP_LITE class FragmentMetadata::GenericTileOffsets::Reader { - public: +public: typedef GenericTileOffsets Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -13668,45 +10513,37 @@ class FragmentMetadata::GenericTileOffsets::Reader { } #endif // !CAPNP_LITE - inline ::uint64_t getRtree() const; + inline ::uint64_t getRtree() const; inline bool hasTileOffsets() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getTileOffsets() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTileOffsets() const; inline bool hasTileVarOffsets() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getTileVarOffsets() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTileVarOffsets() const; inline bool hasTileVarSizes() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getTileVarSizes() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTileVarSizes() const; inline bool hasTileValidityOffsets() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getTileValidityOffsets() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTileValidityOffsets() const; inline bool hasTileMinOffsets() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getTileMinOffsets() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTileMinOffsets() const; inline bool hasTileMaxOffsets() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getTileMaxOffsets() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTileMaxOffsets() const; inline bool hasTileSumOffsets() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getTileSumOffsets() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTileSumOffsets() const; inline bool hasTileNullCountOffsets() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getTileNullCountOffsets() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTileNullCountOffsets() const; - inline ::uint64_t getFragmentMinMaxSumNullCountOffset() const; + inline ::uint64_t getFragmentMinMaxSumNullCountOffset() const; - inline ::uint64_t getProcessedConditionsOffsets() const; + inline ::uint64_t getProcessedConditionsOffsets() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -13719,154 +10556,95 @@ class FragmentMetadata::GenericTileOffsets::Reader { }; class FragmentMetadata::GenericTileOffsets::Builder { - public: +public: typedef GenericTileOffsets Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE - inline ::uint64_t getRtree(); - inline void setRtree(::uint64_t value); + inline ::uint64_t getRtree(); + inline void setRtree( ::uint64_t value); inline bool hasTileOffsets(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getTileOffsets(); - inline void setTileOffsets( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTileOffsets(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initTileOffsets(unsigned int size); - inline void adoptTileOffsets( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownTileOffsets(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTileOffsets(); + inline void setTileOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTileOffsets(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTileOffsets(unsigned int size); + inline void adoptTileOffsets(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTileOffsets(); inline bool hasTileVarOffsets(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getTileVarOffsets(); - inline void setTileVarOffsets( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTileVarOffsets(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initTileVarOffsets(unsigned int size); - inline void adoptTileVarOffsets( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownTileVarOffsets(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTileVarOffsets(); + inline void setTileVarOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTileVarOffsets(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTileVarOffsets(unsigned int size); + inline void adoptTileVarOffsets(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTileVarOffsets(); inline bool hasTileVarSizes(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getTileVarSizes(); - inline void setTileVarSizes( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTileVarSizes(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initTileVarSizes(unsigned int size); - inline void adoptTileVarSizes( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownTileVarSizes(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTileVarSizes(); + inline void setTileVarSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTileVarSizes(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTileVarSizes(unsigned int size); + inline void adoptTileVarSizes(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTileVarSizes(); inline bool hasTileValidityOffsets(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getTileValidityOffsets(); - inline void setTileValidityOffsets( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTileValidityOffsets(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initTileValidityOffsets(unsigned int size); - inline void adoptTileValidityOffsets( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownTileValidityOffsets(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTileValidityOffsets(); + inline void setTileValidityOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTileValidityOffsets(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTileValidityOffsets(unsigned int size); + inline void adoptTileValidityOffsets(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTileValidityOffsets(); inline bool hasTileMinOffsets(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getTileMinOffsets(); - inline void setTileMinOffsets( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTileMinOffsets(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initTileMinOffsets(unsigned int size); - inline void adoptTileMinOffsets( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownTileMinOffsets(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTileMinOffsets(); + inline void setTileMinOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTileMinOffsets(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTileMinOffsets(unsigned int size); + inline void adoptTileMinOffsets(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTileMinOffsets(); inline bool hasTileMaxOffsets(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getTileMaxOffsets(); - inline void setTileMaxOffsets( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTileMaxOffsets(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initTileMaxOffsets(unsigned int size); - inline void adoptTileMaxOffsets( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownTileMaxOffsets(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTileMaxOffsets(); + inline void setTileMaxOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTileMaxOffsets(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTileMaxOffsets(unsigned int size); + inline void adoptTileMaxOffsets(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTileMaxOffsets(); inline bool hasTileSumOffsets(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getTileSumOffsets(); - inline void setTileSumOffsets( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTileSumOffsets(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initTileSumOffsets(unsigned int size); - inline void adoptTileSumOffsets( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownTileSumOffsets(); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTileSumOffsets(); + inline void setTileSumOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTileSumOffsets(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTileSumOffsets(unsigned int size); + inline void adoptTileSumOffsets(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTileSumOffsets(); inline bool hasTileNullCountOffsets(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getTileNullCountOffsets(); - inline void setTileNullCountOffsets( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTileNullCountOffsets(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initTileNullCountOffsets(unsigned int size); - inline void adoptTileNullCountOffsets( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownTileNullCountOffsets(); - - inline ::uint64_t getFragmentMinMaxSumNullCountOffset(); - inline void setFragmentMinMaxSumNullCountOffset(::uint64_t value); - - inline ::uint64_t getProcessedConditionsOffsets(); - inline void setProcessedConditionsOffsets(::uint64_t value); - - private: + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTileNullCountOffsets(); + inline void setTileNullCountOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTileNullCountOffsets(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTileNullCountOffsets(unsigned int size); + inline void adoptTileNullCountOffsets(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTileNullCountOffsets(); + + inline ::uint64_t getFragmentMinMaxSumNullCountOffset(); + inline void setFragmentMinMaxSumNullCountOffset( ::uint64_t value); + + inline ::uint64_t getProcessedConditionsOffsets(); + inline void setProcessedConditionsOffsets( ::uint64_t value); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -13877,17 +10655,14 @@ class FragmentMetadata::GenericTileOffsets::Builder { #if !CAPNP_LITE class FragmentMetadata::GenericTileOffsets::Pipeline { - public: +public: typedef GenericTileOffsets Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -13896,13 +10671,11 @@ class FragmentMetadata::GenericTileOffsets::Pipeline { #endif // !CAPNP_LITE class MultiPartUploadState::Reader { - public: +public: typedef MultiPartUploadState Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -13914,27 +10687,21 @@ class MultiPartUploadState::Reader { } #endif // !CAPNP_LITE - inline ::uint64_t getPartNumber() const; + inline ::uint64_t getPartNumber() const; inline bool hasUploadId() const; - inline ::capnp::Text::Reader getUploadId() const; + inline ::capnp::Text::Reader getUploadId() const; inline bool hasStatus() const; - inline ::capnp::Text::Reader getStatus() const; + inline ::capnp::Text::Reader getStatus() const; inline bool hasCompletedParts() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>::Reader - getCompletedParts() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>::Reader getCompletedParts() const; inline bool hasBufferedChunks() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>::Reader - getBufferedChunks() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>::Reader getBufferedChunks() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -13947,94 +10714,53 @@ class MultiPartUploadState::Reader { }; class MultiPartUploadState::Builder { - public: +public: typedef MultiPartUploadState Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE - inline ::uint64_t getPartNumber(); - inline void setPartNumber(::uint64_t value); + inline ::uint64_t getPartNumber(); + inline void setPartNumber( ::uint64_t value); inline bool hasUploadId(); - inline ::capnp::Text::Builder getUploadId(); - inline void setUploadId(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUploadId(unsigned int size); - inline void adoptUploadId(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownUploadId(); + inline ::capnp::Text::Builder getUploadId(); + inline void setUploadId( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUploadId(unsigned int size); + inline void adoptUploadId(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownUploadId(); inline bool hasStatus(); - inline ::capnp::Text::Builder getStatus(); - inline void setStatus(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initStatus(unsigned int size); - inline void adoptStatus(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownStatus(); + inline ::capnp::Text::Builder getStatus(); + inline void setStatus( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initStatus(unsigned int size); + inline void adoptStatus(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownStatus(); inline bool hasCompletedParts(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>::Builder - getCompletedParts(); - inline void setCompletedParts( - ::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>::Builder - initCompletedParts(unsigned int size); - inline void adoptCompletedParts( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>> - disownCompletedParts(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>::Builder getCompletedParts(); + inline void setCompletedParts( ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>::Builder initCompletedParts(unsigned int size); + inline void adoptCompletedParts(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>> disownCompletedParts(); inline bool hasBufferedChunks(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>::Builder - getBufferedChunks(); - inline void setBufferedChunks( - ::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>::Builder - initBufferedChunks(unsigned int size); - inline void adoptBufferedChunks( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>> - disownBufferedChunks(); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>::Builder getBufferedChunks(); + inline void setBufferedChunks( ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>::Builder initBufferedChunks(unsigned int size); + inline void adoptBufferedChunks(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>> disownBufferedChunks(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -14045,17 +10771,14 @@ class MultiPartUploadState::Builder { #if !CAPNP_LITE class MultiPartUploadState::Pipeline { - public: +public: typedef MultiPartUploadState Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -14064,13 +10787,11 @@ class MultiPartUploadState::Pipeline { #endif // !CAPNP_LITE class CompletedPart::Reader { - public: +public: typedef CompletedPart Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -14083,11 +10804,11 @@ class CompletedPart::Reader { #endif // !CAPNP_LITE inline bool hasETag() const; - inline ::capnp::Text::Reader getETag() const; + inline ::capnp::Text::Reader getETag() const; - inline ::uint64_t getPartNumber() const; + inline ::uint64_t getPartNumber() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -14100,43 +10821,32 @@ class CompletedPart::Reader { }; class CompletedPart::Builder { - public: +public: typedef CompletedPart Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasETag(); - inline ::capnp::Text::Builder getETag(); - inline void setETag(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initETag(unsigned int size); - inline void adoptETag(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownETag(); + inline ::capnp::Text::Builder getETag(); + inline void setETag( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initETag(unsigned int size); + inline void adoptETag(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownETag(); - inline ::uint64_t getPartNumber(); - inline void setPartNumber(::uint64_t value); + inline ::uint64_t getPartNumber(); + inline void setPartNumber( ::uint64_t value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -14147,17 +10857,14 @@ class CompletedPart::Builder { #if !CAPNP_LITE class CompletedPart::Pipeline { - public: +public: typedef CompletedPart Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -14166,13 +10873,11 @@ class CompletedPart::Pipeline { #endif // !CAPNP_LITE class WrittenFragmentInfo::Reader { - public: +public: typedef WrittenFragmentInfo Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -14185,13 +10890,12 @@ class WrittenFragmentInfo::Reader { #endif // !CAPNP_LITE inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; inline bool hasTimestampRange() const; - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader - getTimestampRange() const; + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTimestampRange() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -14204,54 +10908,37 @@ class WrittenFragmentInfo::Reader { }; class WrittenFragmentInfo::Builder { - public: +public: typedef WrittenFragmentInfo Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownUri(); inline bool hasTimestampRange(); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - getTimestampRange(); - inline void setTimestampRange( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTimestampRange(::kj::ArrayPtr value); - inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder - initTimestampRange(unsigned int size); - inline void adoptTimestampRange( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value); - inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> - disownTimestampRange(); - - private: + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTimestampRange(); + inline void setTimestampRange( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTimestampRange(::kj::ArrayPtr value); + inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTimestampRange(unsigned int size); + inline void adoptTimestampRange(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTimestampRange(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -14262,17 +10949,14 @@ class WrittenFragmentInfo::Builder { #if !CAPNP_LITE class WrittenFragmentInfo::Pipeline { - public: +public: typedef WrittenFragmentInfo Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -14281,13 +10965,11 @@ class WrittenFragmentInfo::Pipeline { #endif // !CAPNP_LITE class BufferedChunk::Reader { - public: +public: typedef BufferedChunk Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -14300,11 +10982,11 @@ class BufferedChunk::Reader { #endif // !CAPNP_LITE inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; - inline ::uint64_t getSize() const; + inline ::uint64_t getSize() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -14317,43 +10999,32 @@ class BufferedChunk::Reader { }; class BufferedChunk::Builder { - public: +public: typedef BufferedChunk Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownUri(); - inline ::uint64_t getSize(); - inline void setSize(::uint64_t value); + inline ::uint64_t getSize(); + inline void setSize( ::uint64_t value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -14364,17 +11035,14 @@ class BufferedChunk::Builder { #if !CAPNP_LITE class BufferedChunk::Pipeline { - public: +public: typedef BufferedChunk Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -14383,13 +11051,11 @@ class BufferedChunk::Pipeline { #endif // !CAPNP_LITE class ArrayDeleteFragmentsListRequest::Reader { - public: +public: typedef ArrayDeleteFragmentsListRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -14402,13 +11068,12 @@ class ArrayDeleteFragmentsListRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasEntries() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader getEntries() - const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getEntries() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -14421,57 +11086,37 @@ class ArrayDeleteFragmentsListRequest::Reader { }; class ArrayDeleteFragmentsListRequest::Builder { - public: +public: typedef ArrayDeleteFragmentsListRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> - disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); inline bool hasEntries(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getEntries(); - inline void setEntries( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setEntries(::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder initEntries( - unsigned int size); - inline void adoptEntries( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownEntries(); - - private: + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getEntries(); + inline void setEntries( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setEntries(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initEntries(unsigned int size); + inline void adoptEntries(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownEntries(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -14482,19 +11127,15 @@ class ArrayDeleteFragmentsListRequest::Builder { #if !CAPNP_LITE class ArrayDeleteFragmentsListRequest::Pipeline { - public: +public: typedef ArrayDeleteFragmentsListRequest Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -14503,13 +11144,11 @@ class ArrayDeleteFragmentsListRequest::Pipeline { #endif // !CAPNP_LITE class ArrayDeleteFragmentsTimestampsRequest::Reader { - public: +public: typedef ArrayDeleteFragmentsTimestampsRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -14522,13 +11161,13 @@ class ArrayDeleteFragmentsTimestampsRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; - inline ::uint64_t getStartTimestamp() const; + inline ::uint64_t getStartTimestamp() const; - inline ::uint64_t getEndTimestamp() const; + inline ::uint64_t getEndTimestamp() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -14541,49 +11180,35 @@ class ArrayDeleteFragmentsTimestampsRequest::Reader { }; class ArrayDeleteFragmentsTimestampsRequest::Builder { - public: +public: typedef ArrayDeleteFragmentsTimestampsRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> - disownConfig(); - - inline ::uint64_t getStartTimestamp(); - inline void setStartTimestamp(::uint64_t value); - - inline ::uint64_t getEndTimestamp(); - inline void setEndTimestamp(::uint64_t value); - - private: + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); + + inline ::uint64_t getStartTimestamp(); + inline void setStartTimestamp( ::uint64_t value); + + inline ::uint64_t getEndTimestamp(); + inline void setEndTimestamp( ::uint64_t value); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -14594,19 +11219,15 @@ class ArrayDeleteFragmentsTimestampsRequest::Builder { #if !CAPNP_LITE class ArrayDeleteFragmentsTimestampsRequest::Pipeline { - public: +public: typedef ArrayDeleteFragmentsTimestampsRequest Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - - private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -14615,13 +11236,11 @@ class ArrayDeleteFragmentsTimestampsRequest::Pipeline { #endif // !CAPNP_LITE class ArrayConsolidationRequest::Reader { - public: +public: typedef ArrayConsolidationRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -14634,13 +11253,12 @@ class ArrayConsolidationRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasFragments() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getFragments() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getFragments() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -14653,57 +11271,37 @@ class ArrayConsolidationRequest::Reader { }; class ArrayConsolidationRequest::Builder { - public: +public: typedef ArrayConsolidationRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> - disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); inline bool hasFragments(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getFragments(); - inline void setFragments( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setFragments(::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initFragments(unsigned int size); - inline void adoptFragments( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownFragments(); - - private: + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getFragments(); + inline void setFragments( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setFragments(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initFragments(unsigned int size); + inline void adoptFragments(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownFragments(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -14714,19 +11312,15 @@ class ArrayConsolidationRequest::Builder { #if !CAPNP_LITE class ArrayConsolidationRequest::Pipeline { - public: +public: typedef ArrayConsolidationRequest Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - - private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -14735,13 +11329,11 @@ class ArrayConsolidationRequest::Pipeline { #endif // !CAPNP_LITE class ArrayVacuumRequest::Reader { - public: +public: typedef ArrayVacuumRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -14754,9 +11346,9 @@ class ArrayVacuumRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -14769,43 +11361,29 @@ class ArrayVacuumRequest::Reader { }; class ArrayVacuumRequest::Builder { - public: +public: typedef ArrayVacuumRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> - disownConfig(); - - private: + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -14816,19 +11394,15 @@ class ArrayVacuumRequest::Builder { #if !CAPNP_LITE class ArrayVacuumRequest::Pipeline { - public: +public: typedef ArrayVacuumRequest Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -14837,13 +11411,11 @@ class ArrayVacuumRequest::Pipeline { #endif // !CAPNP_LITE class LoadEnumerationsRequest::Reader { - public: +public: typedef LoadEnumerationsRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -14856,13 +11428,12 @@ class LoadEnumerationsRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasEnumerations() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getEnumerations() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getEnumerations() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -14875,58 +11446,37 @@ class LoadEnumerationsRequest::Reader { }; class LoadEnumerationsRequest::Builder { - public: +public: typedef LoadEnumerationsRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> - disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); inline bool hasEnumerations(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getEnumerations(); - inline void setEnumerations( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setEnumerations( - ::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initEnumerations(unsigned int size); - inline void adoptEnumerations( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownEnumerations(); - - private: + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getEnumerations(); + inline void setEnumerations( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setEnumerations(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initEnumerations(unsigned int size); + inline void adoptEnumerations(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownEnumerations(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -14937,19 +11487,15 @@ class LoadEnumerationsRequest::Builder { #if !CAPNP_LITE class LoadEnumerationsRequest::Pipeline { - public: +public: typedef LoadEnumerationsRequest Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -14958,13 +11504,11 @@ class LoadEnumerationsRequest::Pipeline { #endif // !CAPNP_LITE class LoadEnumerationsResponse::Reader { - public: +public: typedef LoadEnumerationsResponse Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -14977,16 +11521,12 @@ class LoadEnumerationsResponse::Reader { #endif // !CAPNP_LITE inline bool hasEnumerations() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader - getEnumerations() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader getEnumerations() const; inline bool hasAllEnumerations() const; - inline ::tiledb::sm::serialization::capnp::MapEnumeration::Reader - getAllEnumerations() const; + inline ::tiledb::sm::serialization::capnp::MapEnumeration::Reader getAllEnumerations() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -14999,67 +11539,36 @@ class LoadEnumerationsResponse::Reader { }; class LoadEnumerationsResponse::Builder { - public: +public: typedef LoadEnumerationsResponse Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasEnumerations(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder - getEnumerations(); - inline void setEnumerations(::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder - initEnumerations(unsigned int size); - inline void adoptEnumerations( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>> - disownEnumerations(); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder getEnumerations(); + inline void setEnumerations( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder initEnumerations(unsigned int size); + inline void adoptEnumerations(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> disownEnumerations(); inline bool hasAllEnumerations(); - inline ::tiledb::sm::serialization::capnp::MapEnumeration::Builder - getAllEnumerations(); - inline void setAllEnumerations( - ::tiledb::sm::serialization::capnp::MapEnumeration::Reader value); - inline ::tiledb::sm::serialization::capnp::MapEnumeration::Builder - initAllEnumerations(); - inline void adoptAllEnumerations( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapEnumeration>&& - value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapEnumeration> - disownAllEnumerations(); - - private: + inline ::tiledb::sm::serialization::capnp::MapEnumeration::Builder getAllEnumerations(); + inline void setAllEnumerations( ::tiledb::sm::serialization::capnp::MapEnumeration::Reader value); + inline ::tiledb::sm::serialization::capnp::MapEnumeration::Builder initAllEnumerations(); + inline void adoptAllEnumerations(::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapEnumeration>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapEnumeration> disownAllEnumerations(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -15070,20 +11579,15 @@ class LoadEnumerationsResponse::Builder { #if !CAPNP_LITE class LoadEnumerationsResponse::Pipeline { - public: +public: typedef LoadEnumerationsResponse Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::MapEnumeration::Pipeline - getAllEnumerations(); - - private: + inline ::tiledb::sm::serialization::capnp::MapEnumeration::Pipeline getAllEnumerations(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -15092,13 +11596,11 @@ class LoadEnumerationsResponse::Pipeline { #endif // !CAPNP_LITE class LoadArraySchemaRequest::Reader { - public: +public: typedef LoadArraySchemaRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -15111,11 +11613,11 @@ class LoadArraySchemaRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool getIncludeEnumerations() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -15128,46 +11630,32 @@ class LoadArraySchemaRequest::Reader { }; class LoadArraySchemaRequest::Builder { - public: +public: typedef LoadArraySchemaRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> - disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); inline bool getIncludeEnumerations(); inline void setIncludeEnumerations(bool value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -15178,19 +11666,15 @@ class LoadArraySchemaRequest::Builder { #if !CAPNP_LITE class LoadArraySchemaRequest::Pipeline { - public: +public: typedef LoadArraySchemaRequest Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - - private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -15199,13 +11683,11 @@ class LoadArraySchemaRequest::Pipeline { #endif // !CAPNP_LITE class LoadArraySchemaResponse::Reader { - public: +public: typedef LoadArraySchemaResponse Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -15218,16 +11700,12 @@ class LoadArraySchemaResponse::Reader { #endif // !CAPNP_LITE inline bool hasSchema() const; - inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader getSchema() - const; + inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader getSchema() const; inline bool hasArraySchemasAll() const; - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Reader - getArraySchemasAll() const; + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader getArraySchemasAll() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -15240,65 +11718,36 @@ class LoadArraySchemaResponse::Reader { }; class LoadArraySchemaResponse::Builder { - public: +public: typedef LoadArraySchemaResponse Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasSchema(); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder getSchema(); - inline void setSchema( - ::tiledb::sm::serialization::capnp::ArraySchema::Reader value); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder initSchema(); - inline void adoptSchema( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema> - disownSchema(); + inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder getSchema(); + inline void setSchema( ::tiledb::sm::serialization::capnp::ArraySchema::Reader value); + inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder initSchema(); + inline void adoptSchema(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema> disownSchema(); inline bool hasArraySchemasAll(); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Builder - getArraySchemasAll(); - inline void setArraySchemasAll( - ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Builder - initArraySchemasAll(); - inline void adoptArraySchemasAll( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>> - disownArraySchemasAll(); - - private: + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder getArraySchemasAll(); + inline void setArraySchemasAll( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value); + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder initArraySchemasAll(); + inline void adoptArraySchemasAll(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>> disownArraySchemasAll(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -15309,23 +11758,16 @@ class LoadArraySchemaResponse::Builder { #if !CAPNP_LITE class LoadArraySchemaResponse::Pipeline { - public: +public: typedef LoadArraySchemaResponse Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline getSchema(); - inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline - getArraySchemasAll(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline getSchema(); + inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline getArraySchemasAll(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -15334,13 +11776,11 @@ class LoadArraySchemaResponse::Pipeline { #endif // !CAPNP_LITE class QueryPlanRequest::Reader { - public: +public: typedef QueryPlanRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -15353,12 +11793,12 @@ class QueryPlanRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasQuery() const; - inline ::tiledb::sm::serialization::capnp::Query::Reader getQuery() const; + inline ::tiledb::sm::serialization::capnp::Query::Reader getQuery() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -15371,52 +11811,36 @@ class QueryPlanRequest::Reader { }; class QueryPlanRequest::Builder { - public: +public: typedef QueryPlanRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> - disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); inline bool hasQuery(); - inline ::tiledb::sm::serialization::capnp::Query::Builder getQuery(); - inline void setQuery(::tiledb::sm::serialization::capnp::Query::Reader value); - inline ::tiledb::sm::serialization::capnp::Query::Builder initQuery(); - inline void adoptQuery( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Query>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Query> - disownQuery(); - - private: + inline ::tiledb::sm::serialization::capnp::Query::Builder getQuery(); + inline void setQuery( ::tiledb::sm::serialization::capnp::Query::Reader value); + inline ::tiledb::sm::serialization::capnp::Query::Builder initQuery(); + inline void adoptQuery(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Query>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Query> disownQuery(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -15427,20 +11851,16 @@ class QueryPlanRequest::Builder { #if !CAPNP_LITE class QueryPlanRequest::Pipeline { - public: +public: typedef QueryPlanRequest Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::Query::Pipeline getQuery(); - - private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + inline ::tiledb::sm::serialization::capnp::Query::Pipeline getQuery(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -15449,13 +11869,11 @@ class QueryPlanRequest::Pipeline { #endif // !CAPNP_LITE class QueryPlanResponse::Reader { - public: +public: typedef QueryPlanResponse Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -15468,23 +11886,21 @@ class QueryPlanResponse::Reader { #endif // !CAPNP_LITE inline bool hasQueryLayout() const; - inline ::capnp::Text::Reader getQueryLayout() const; + inline ::capnp::Text::Reader getQueryLayout() const; inline bool hasStrategyName() const; - inline ::capnp::Text::Reader getStrategyName() const; + inline ::capnp::Text::Reader getStrategyName() const; inline bool hasArrayType() const; - inline ::capnp::Text::Reader getArrayType() const; + inline ::capnp::Text::Reader getArrayType() const; inline bool hasAttributeNames() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getAttributeNames() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getAttributeNames() const; inline bool hasDimensionNames() const; - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader - getDimensionNames() const; + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getDimensionNames() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -15497,84 +11913,59 @@ class QueryPlanResponse::Reader { }; class QueryPlanResponse::Builder { - public: +public: typedef QueryPlanResponse Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasQueryLayout(); - inline ::capnp::Text::Builder getQueryLayout(); - inline void setQueryLayout(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initQueryLayout(unsigned int size); - inline void adoptQueryLayout(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownQueryLayout(); + inline ::capnp::Text::Builder getQueryLayout(); + inline void setQueryLayout( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initQueryLayout(unsigned int size); + inline void adoptQueryLayout(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownQueryLayout(); inline bool hasStrategyName(); - inline ::capnp::Text::Builder getStrategyName(); - inline void setStrategyName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initStrategyName(unsigned int size); - inline void adoptStrategyName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownStrategyName(); + inline ::capnp::Text::Builder getStrategyName(); + inline void setStrategyName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initStrategyName(unsigned int size); + inline void adoptStrategyName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownStrategyName(); inline bool hasArrayType(); - inline ::capnp::Text::Builder getArrayType(); - inline void setArrayType(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initArrayType(unsigned int size); - inline void adoptArrayType(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownArrayType(); + inline ::capnp::Text::Builder getArrayType(); + inline void setArrayType( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initArrayType(unsigned int size); + inline void adoptArrayType(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownArrayType(); inline bool hasAttributeNames(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getAttributeNames(); - inline void setAttributeNames( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setAttributeNames( - ::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initAttributeNames(unsigned int size); - inline void adoptAttributeNames( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownAttributeNames(); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getAttributeNames(); + inline void setAttributeNames( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setAttributeNames(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initAttributeNames(unsigned int size); + inline void adoptAttributeNames(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownAttributeNames(); inline bool hasDimensionNames(); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - getDimensionNames(); - inline void setDimensionNames( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setDimensionNames( - ::kj::ArrayPtr value); - inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder - initDimensionNames(unsigned int size); - inline void adoptDimensionNames( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value); - inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> - disownDimensionNames(); - - private: + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getDimensionNames(); + inline void setDimensionNames( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setDimensionNames(::kj::ArrayPtr value); + inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initDimensionNames(unsigned int size); + inline void adoptDimensionNames(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownDimensionNames(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -15585,17 +11976,14 @@ class QueryPlanResponse::Builder { #if !CAPNP_LITE class QueryPlanResponse::Pipeline { - public: +public: typedef QueryPlanResponse Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -15604,13 +11992,11 @@ class QueryPlanResponse::Pipeline { #endif // !CAPNP_LITE class ConsolidationPlanRequest::Reader { - public: +public: typedef ConsolidationPlanRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -15623,11 +12009,11 @@ class ConsolidationPlanRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; - inline ::uint64_t getFragmentSize() const; + inline ::uint64_t getFragmentSize() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -15640,46 +12026,32 @@ class ConsolidationPlanRequest::Reader { }; class ConsolidationPlanRequest::Builder { - public: +public: typedef ConsolidationPlanRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> - disownConfig(); - - inline ::uint64_t getFragmentSize(); - inline void setFragmentSize(::uint64_t value); - - private: + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); + + inline ::uint64_t getFragmentSize(); + inline void setFragmentSize( ::uint64_t value); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -15690,19 +12062,15 @@ class ConsolidationPlanRequest::Builder { #if !CAPNP_LITE class ConsolidationPlanRequest::Pipeline { - public: +public: typedef ConsolidationPlanRequest Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + : _typeless(kj::mv(typeless)) {} - private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -15711,13 +12079,11 @@ class ConsolidationPlanRequest::Pipeline { #endif // !CAPNP_LITE class ConsolidationPlanResponse::Reader { - public: +public: typedef ConsolidationPlanResponse Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -15730,12 +12096,9 @@ class ConsolidationPlanResponse::Reader { #endif // !CAPNP_LITE inline bool hasFragmentUrisPerNode() const; - inline ::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>::Reader - getFragmentUrisPerNode() const; + inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Reader getFragmentUrisPerNode() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -15748,59 +12111,30 @@ class ConsolidationPlanResponse::Reader { }; class ConsolidationPlanResponse::Builder { - public: +public: typedef ConsolidationPlanResponse Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasFragmentUrisPerNode(); - inline ::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>::Builder - getFragmentUrisPerNode(); - inline void setFragmentUrisPerNode( - ::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>::Reader value); - inline void setFragmentUrisPerNode( - ::kj::ArrayPtr< - const ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader> - value); - inline ::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>::Builder - initFragmentUrisPerNode(unsigned int size); - inline void adoptFragmentUrisPerNode( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>> - disownFragmentUrisPerNode(); - - private: + inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Builder getFragmentUrisPerNode(); + inline void setFragmentUrisPerNode( ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Reader value); + inline void setFragmentUrisPerNode(::kj::ArrayPtr::Reader> value); + inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Builder initFragmentUrisPerNode(unsigned int size); + inline void adoptFragmentUrisPerNode(::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>> disownFragmentUrisPerNode(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -15811,17 +12145,14 @@ class ConsolidationPlanResponse::Builder { #if !CAPNP_LITE class ConsolidationPlanResponse::Pipeline { - public: +public: typedef ConsolidationPlanResponse Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -15830,13 +12161,11 @@ class ConsolidationPlanResponse::Pipeline { #endif // !CAPNP_LITE class QueryChannel::Reader { - public: +public: typedef QueryChannel Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -15851,12 +12180,9 @@ class QueryChannel::Reader { inline bool getDefault() const; inline bool hasAggregates() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>::Reader - getAggregates() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>::Reader getAggregates() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -15869,56 +12195,32 @@ class QueryChannel::Reader { }; class QueryChannel::Builder { - public: +public: typedef QueryChannel Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool getDefault(); inline void setDefault(bool value); inline bool hasAggregates(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>::Builder - getAggregates(); - inline void setAggregates(::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>::Builder - initAggregates(unsigned int size); - inline void adoptAggregates(::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>> - disownAggregates(); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>::Builder getAggregates(); + inline void setAggregates( ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>::Builder initAggregates(unsigned int size); + inline void adoptAggregates(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>> disownAggregates(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -15929,17 +12231,14 @@ class QueryChannel::Builder { #if !CAPNP_LITE class QueryChannel::Pipeline { - public: +public: typedef QueryChannel Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -15948,13 +12247,11 @@ class QueryChannel::Pipeline { #endif // !CAPNP_LITE class Aggregate::Reader { - public: +public: typedef Aggregate Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -15967,15 +12264,15 @@ class Aggregate::Reader { #endif // !CAPNP_LITE inline bool hasOutputFieldName() const; - inline ::capnp::Text::Reader getOutputFieldName() const; + inline ::capnp::Text::Reader getOutputFieldName() const; inline bool hasInputFieldName() const; - inline ::capnp::Text::Reader getInputFieldName() const; + inline ::capnp::Text::Reader getInputFieldName() const; inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -15988,54 +12285,43 @@ class Aggregate::Reader { }; class Aggregate::Builder { - public: +public: typedef Aggregate Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasOutputFieldName(); - inline ::capnp::Text::Builder getOutputFieldName(); - inline void setOutputFieldName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initOutputFieldName(unsigned int size); - inline void adoptOutputFieldName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownOutputFieldName(); + inline ::capnp::Text::Builder getOutputFieldName(); + inline void setOutputFieldName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initOutputFieldName(unsigned int size); + inline void adoptOutputFieldName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownOutputFieldName(); inline bool hasInputFieldName(); - inline ::capnp::Text::Builder getInputFieldName(); - inline void setInputFieldName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initInputFieldName(unsigned int size); - inline void adoptInputFieldName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownInputFieldName(); + inline ::capnp::Text::Builder getInputFieldName(); + inline void setInputFieldName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initInputFieldName(unsigned int size); + inline void adoptInputFieldName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownInputFieldName(); inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownName(); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -16046,17 +12332,14 @@ class Aggregate::Builder { #if !CAPNP_LITE class Aggregate::Pipeline { - public: +public: typedef Aggregate Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -16065,13 +12348,11 @@ class Aggregate::Pipeline { #endif // !CAPNP_LITE class CurrentDomain::Reader { - public: +public: typedef CurrentDomain Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -16084,20 +12365,19 @@ class CurrentDomain::Reader { #endif // !CAPNP_LITE inline Which which() const; - inline ::uint32_t getVersion() const; + inline ::uint32_t getVersion() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; inline bool isEmptyCurrentDomain() const; - inline ::capnp::Void getEmptyCurrentDomain() const; + inline ::capnp::Void getEmptyCurrentDomain() const; inline bool isNdRectangle() const; inline bool hasNdRectangle() const; - inline ::tiledb::sm::serialization::capnp::NDRectangle::Reader - getNdRectangle() const; + inline ::tiledb::sm::serialization::capnp::NDRectangle::Reader getNdRectangle() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -16110,61 +12390,45 @@ class CurrentDomain::Reader { }; class CurrentDomain::Builder { - public: +public: typedef CurrentDomain Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline Which which(); - inline ::uint32_t getVersion(); - inline void setVersion(::uint32_t value); + inline ::uint32_t getVersion(); + inline void setVersion( ::uint32_t value); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType(::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); - inline ::capnp::Orphan<::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownType(); inline bool isEmptyCurrentDomain(); - inline ::capnp::Void getEmptyCurrentDomain(); - inline void setEmptyCurrentDomain(::capnp::Void value = ::capnp::VOID); + inline ::capnp::Void getEmptyCurrentDomain(); + inline void setEmptyCurrentDomain( ::capnp::Void value = ::capnp::VOID); inline bool isNdRectangle(); inline bool hasNdRectangle(); - inline ::tiledb::sm::serialization::capnp::NDRectangle::Builder - getNdRectangle(); - inline void setNdRectangle( - ::tiledb::sm::serialization::capnp::NDRectangle::Reader value); - inline ::tiledb::sm::serialization::capnp::NDRectangle::Builder - initNdRectangle(); - inline void adoptNdRectangle( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::NDRectangle>&& value); - inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::NDRectangle> - disownNdRectangle(); - - private: + inline ::tiledb::sm::serialization::capnp::NDRectangle::Builder getNdRectangle(); + inline void setNdRectangle( ::tiledb::sm::serialization::capnp::NDRectangle::Reader value); + inline ::tiledb::sm::serialization::capnp::NDRectangle::Builder initNdRectangle(); + inline void adoptNdRectangle(::capnp::Orphan< ::tiledb::sm::serialization::capnp::NDRectangle>&& value); + inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NDRectangle> disownNdRectangle(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -16175,17 +12439,14 @@ class CurrentDomain::Builder { #if !CAPNP_LITE class CurrentDomain::Pipeline { - public: +public: typedef CurrentDomain Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -16194,13 +12455,11 @@ class CurrentDomain::Pipeline { #endif // !CAPNP_LITE class NDRectangle::Reader { - public: +public: typedef NDRectangle Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -16213,12 +12472,9 @@ class NDRectangle::Reader { #endif // !CAPNP_LITE inline bool hasNdranges() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>::Reader - getNdranges() const; + inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Reader getNdranges() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -16231,54 +12487,29 @@ class NDRectangle::Reader { }; class NDRectangle::Builder { - public: +public: typedef NDRectangle Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE inline bool hasNdranges(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>::Builder - getNdranges(); - inline void setNdranges(::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>::Builder - initNdranges(unsigned int size); - inline void adoptNdranges( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>> - disownNdranges(); - - private: + inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Builder getNdranges(); + inline void setNdranges( ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Builder initNdranges(unsigned int size); + inline void adoptNdranges(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>> disownNdranges(); + +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -16289,17 +12520,14 @@ class NDRectangle::Builder { #if !CAPNP_LITE class NDRectangle::Pipeline { - public: +public: typedef NDRectangle Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -16308,13 +12536,11 @@ class NDRectangle::Pipeline { #endif // !CAPNP_LITE class ObjectInfoResponse::Reader { - public: +public: typedef ObjectInfoResponse Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -16326,9 +12552,9 @@ class ObjectInfoResponse::Reader { } #endif // !CAPNP_LITE - inline ::tiledb::sm::serialization::capnp::ObjectType getObjectType() const; + inline ::tiledb::sm::serialization::capnp::ObjectType getObjectType() const; - private: +private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -16341,37 +12567,25 @@ class ObjectInfoResponse::Reader { }; class ObjectInfoResponse::Builder { - public: +public: typedef ObjectInfoResponse Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } + inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } + inline ::kj::StringTree toString() const { return asReader().toString(); } #endif // !CAPNP_LITE - inline ::tiledb::sm::serialization::capnp::ObjectType getObjectType(); - inline void setObjectType( - ::tiledb::sm::serialization::capnp::ObjectType value); + inline ::tiledb::sm::serialization::capnp::ObjectType getObjectType(); + inline void setObjectType( ::tiledb::sm::serialization::capnp::ObjectType value); - private: +private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -16382,17 +12596,14 @@ class ObjectInfoResponse::Builder { #if !CAPNP_LITE class ObjectInfoResponse::Pipeline { - public: +public: typedef ObjectInfoResponse Pipelines; - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } + : _typeless(kj::mv(typeless)) {} - private: +private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -16403,1747 +12614,1241 @@ class ObjectInfoResponse::Pipeline { // ======================================================================================= inline bool DomainArray::Reader::hasInt8() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool DomainArray::Builder::hasInt8() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>::Reader -DomainArray::Reader::getInt8() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>::Builder -DomainArray::Builder::getInt8() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setInt8( - ::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline void DomainArray::Builder::setInt8( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>::Builder -DomainArray::Builder::initInt8(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Reader DomainArray::Reader::getInt8() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::getInt8() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setInt8( ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline void DomainArray::Builder::setInt8(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::initInt8(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void DomainArray::Builder::adoptInt8( - ::capnp::Orphan<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>> -DomainArray::Builder::disownInt8() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>> DomainArray::Builder::disownInt8() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasUint8() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool DomainArray::Builder::hasUint8() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader -DomainArray::Reader::getUint8() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder -DomainArray::Builder::getUint8() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setUint8( - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline void DomainArray::Builder::setUint8( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder -DomainArray::Builder::initUint8(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader DomainArray::Reader::getUint8() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::getUint8() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setUint8( ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline void DomainArray::Builder::setUint8(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::initUint8(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void DomainArray::Builder::adoptUint8( - ::capnp::Orphan<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>> -DomainArray::Builder::disownUint8() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>> DomainArray::Builder::disownUint8() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasInt16() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool DomainArray::Builder::hasInt16() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>::Reader -DomainArray::Reader::getInt16() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>::Builder -DomainArray::Builder::getInt16() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setInt16( - ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline void DomainArray::Builder::setInt16( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>::Builder -DomainArray::Builder::initInt16(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Reader DomainArray::Reader::getInt16() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::getInt16() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setInt16( ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline void DomainArray::Builder::setInt16(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::initInt16(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void DomainArray::Builder::adoptInt16( - ::capnp::Orphan<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>::adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>> -DomainArray::Builder::disownInt16() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>> DomainArray::Builder::disownInt16() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasUint16() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool DomainArray::Builder::hasUint16() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader -DomainArray::Reader::getUint16() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder -DomainArray::Builder::getUint16() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setUint16( - ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline void DomainArray::Builder::setUint16( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder -DomainArray::Builder::initUint16(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader DomainArray::Reader::getUint16() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::getUint16() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setUint16( ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline void DomainArray::Builder::setUint16(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::initUint16(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); } inline void DomainArray::Builder::adoptUint16( - ::capnp::Orphan<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>> -DomainArray::Builder::disownUint16() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>> DomainArray::Builder::disownUint16() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasInt32() const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool DomainArray::Builder::hasInt32() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Reader -DomainArray::Reader::getInt32() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Builder -DomainArray::Builder::getInt32() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setInt32( - ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); -} -inline void DomainArray::Builder::setInt32( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Builder -DomainArray::Builder::initInt32(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader DomainArray::Reader::getInt32() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::getInt32() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setInt32( ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline void DomainArray::Builder::setInt32(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::initInt32(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); } inline void DomainArray::Builder::adoptInt32( - ::capnp::Orphan<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>> -DomainArray::Builder::disownInt32() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>> DomainArray::Builder::disownInt32() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasUint32() const { - return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } inline bool DomainArray::Builder::hasUint32() { - return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader -DomainArray::Reader::getUint32() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder -DomainArray::Builder::getUint32() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setUint32( - ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - value); -} -inline void DomainArray::Builder::setUint32( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder -DomainArray::Builder::initUint32(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader DomainArray::Reader::getUint32() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::getUint32() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setUint32( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline void DomainArray::Builder::setUint32(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::initUint32(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), size); } inline void DomainArray::Builder::adoptUint32( - ::capnp::Orphan<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>> -DomainArray::Builder::disownUint32() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> DomainArray::Builder::disownUint32() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasInt64() const { - return !_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); } inline bool DomainArray::Builder::hasInt64() { - return !_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>::Reader -DomainArray::Reader::getInt64() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>::Builder -DomainArray::Builder::getInt64() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setInt64( - ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - value); -} -inline void DomainArray::Builder::setInt64( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>::Builder -DomainArray::Builder::initInt64(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader DomainArray::Reader::getInt64() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::getInt64() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setInt64( ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline void DomainArray::Builder::setInt64(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::initInt64(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), size); } inline void DomainArray::Builder::adoptInt64( - ::capnp::Orphan<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>::adopt( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>> -DomainArray::Builder::disownInt64() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>> DomainArray::Builder::disownInt64() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasUint64() const { - return !_reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); } inline bool DomainArray::Builder::hasUint64() { - return !_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -DomainArray::Reader::getUint64() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -DomainArray::Builder::getUint64() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setUint64( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - value); -} -inline void DomainArray::Builder::setUint64( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -DomainArray::Builder::initUint64(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader DomainArray::Reader::getUint64() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::getUint64() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setUint64( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline void DomainArray::Builder::setUint64(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::initUint64(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), size); } inline void DomainArray::Builder::adoptUint64( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -DomainArray::Builder::disownUint64() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> DomainArray::Builder::disownUint64() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasFloat32() const { - return !_reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); } inline bool DomainArray::Builder::hasFloat32() { - return !_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List::Reader -DomainArray::Reader::getFloat32() const { - return ::capnp::_:: - PointerHelpers<::capnp::List>::get( - _reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); -} -inline ::capnp::List::Builder -DomainArray::Builder::getFloat32() { - return ::capnp::_:: - PointerHelpers<::capnp::List>::get( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setFloat32( - ::capnp::List::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List>:: - set(_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - value); -} -inline void DomainArray::Builder::setFloat32( - ::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers<::capnp::List>:: - set(_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List::Builder -DomainArray::Builder::initFloat32(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List>::init( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List::Reader DomainArray::Reader::getFloat32() const { + return ::capnp::_::PointerHelpers< ::capnp::List>::get(_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline ::capnp::List::Builder DomainArray::Builder::getFloat32() { + return ::capnp::_::PointerHelpers< ::capnp::List>::get(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setFloat32( ::capnp::List::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline void DomainArray::Builder::setFloat32(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline ::capnp::List::Builder DomainArray::Builder::initFloat32(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List>::init(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), size); } inline void DomainArray::Builder::adoptFloat32( - ::capnp::Orphan<::capnp::List>&& value) { - ::capnp::_::PointerHelpers<::capnp::List>:: - adopt( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List>::adopt(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List> -DomainArray::Builder::disownFloat32() { - return ::capnp::_:: - PointerHelpers<::capnp::List>::disown( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List> DomainArray::Builder::disownFloat32() { + return ::capnp::_::PointerHelpers< ::capnp::List>::disown(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasFloat64() const { - return !_reader.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); } inline bool DomainArray::Builder::hasFloat64() { - return !_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List::Reader -DomainArray::Reader::getFloat64() const { - return ::capnp::_:: - PointerHelpers<::capnp::List>::get( - _reader.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); -} -inline ::capnp::List::Builder -DomainArray::Builder::getFloat64() { - return ::capnp::_:: - PointerHelpers<::capnp::List>::get( - _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setFloat64( - ::capnp::List::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List>:: - set(_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), - value); -} -inline void DomainArray::Builder::setFloat64( - ::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers<::capnp::List>:: - set(_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List::Builder -DomainArray::Builder::initFloat64(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List>::init( - _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List::Reader DomainArray::Reader::getFloat64() const { + return ::capnp::_::PointerHelpers< ::capnp::List>::get(_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} +inline ::capnp::List::Builder DomainArray::Builder::getFloat64() { + return ::capnp::_::PointerHelpers< ::capnp::List>::get(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setFloat64( ::capnp::List::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), value); +} +inline void DomainArray::Builder::setFloat64(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), value); +} +inline ::capnp::List::Builder DomainArray::Builder::initFloat64(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List>::init(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), size); } inline void DomainArray::Builder::adoptFloat64( - ::capnp::Orphan<::capnp::List>&& value) { - ::capnp::_::PointerHelpers<::capnp::List>:: - adopt( - _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List>::adopt(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List> -DomainArray::Builder::disownFloat64() { - return ::capnp::_:: - PointerHelpers<::capnp::List>::disown( - _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List> DomainArray::Builder::disownFloat64() { + return ::capnp::_::PointerHelpers< ::capnp::List>::disown(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); } inline bool KV::Reader::hasKey() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool KV::Builder::hasKey() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader KV::Reader::getKey() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader KV::Reader::getKey() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder KV::Builder::getKey() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder KV::Builder::getKey() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void KV::Builder::setKey(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void KV::Builder::setKey( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder KV::Builder::initKey(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder KV::Builder::initKey(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } -inline void KV::Builder::adoptKey(::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); +inline void KV::Builder::adoptKey( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> KV::Builder::disownKey() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> KV::Builder::disownKey() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool KV::Reader::hasValue() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool KV::Builder::hasValue() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader KV::Reader::getValue() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader KV::Reader::getValue() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder KV::Builder::getValue() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder KV::Builder::getValue() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void KV::Builder::setValue(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void KV::Builder::setValue( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder KV::Builder::initValue(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder KV::Builder::initValue(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } -inline void KV::Builder::adoptValue(::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); +inline void KV::Builder::adoptValue( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> KV::Builder::disownValue() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> KV::Builder::disownValue() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Config::Reader::hasEntries() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool Config::Builder::hasEntries() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp:: - List<::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader - Config::Reader::getEntries() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp:: - List<::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder - Config::Builder::getEntries() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void Config::Builder::setEntries(::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp:: - List<::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder - Config::Builder::initEntries(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader Config::Reader::getEntries() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder Config::Builder::getEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void Config::Builder::setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder Config::Builder::initEntries(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void Config::Builder::adoptEntries( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>> -Config::Builder::disownEntries() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} - -inline ::uint64_t Array::Reader::getEndTimestamp() const { - return _reader.getDataField<::uint64_t>( + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>> Config::Builder::disownEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::uint64_t Array::Reader::getEndTimestamp() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t Array::Builder::getEndTimestamp() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t Array::Builder::getEndTimestamp() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void Array::Builder::setEndTimestamp(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void Array::Builder::setEndTimestamp( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool Array::Reader::hasQueryType() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool Array::Builder::hasQueryType() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Array::Reader::getQueryType() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Array::Reader::getQueryType() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Array::Builder::getQueryType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Array::Builder::getQueryType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Array::Builder::setQueryType(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void Array::Builder::setQueryType( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Array::Builder::initQueryType(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Array::Builder::initQueryType(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void Array::Builder::adoptQueryType( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Array::Builder::disownQueryType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Array::Builder::disownQueryType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Array::Reader::hasUri() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool Array::Builder::hasUri() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Array::Reader::getUri() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Array::Reader::getUri() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Array::Builder::getUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Array::Builder::getUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void Array::Builder::setUri(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void Array::Builder::setUri( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Array::Builder::initUri(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Array::Builder::initUri(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } -inline void Array::Builder::adoptUri(::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); +inline void Array::Builder::adoptUri( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Array::Builder::disownUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Array::Builder::disownUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::uint64_t Array::Reader::getStartTimestamp() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t Array::Reader::getStartTimestamp() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t Array::Builder::getStartTimestamp() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t Array::Builder::getStartTimestamp() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Array::Builder::setStartTimestamp(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void Array::Builder::setStartTimestamp( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool Array::Reader::hasArraySchemaLatest() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool Array::Builder::hasArraySchemaLatest() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader -Array::Reader::getArraySchemaLatest() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader Array::Reader::getArraySchemaLatest() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder -Array::Builder::getArraySchemaLatest() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder Array::Builder::getArraySchemaLatest() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline -Array::Pipeline::getArraySchemaLatest() { - return ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline( - _typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline Array::Pipeline::getArraySchemaLatest() { + return ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline(_typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void Array::Builder::setArraySchemaLatest( - ::tiledb::sm::serialization::capnp::ArraySchema::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>:: - set(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void Array::Builder::setArraySchemaLatest( ::tiledb::sm::serialization::capnp::ArraySchema::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder -Array::Builder::initArraySchemaLatest() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder Array::Builder::initArraySchemaLatest() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void Array::Builder::adoptArraySchemaLatest( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>:: - adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema> -Array::Builder::disownArraySchemaLatest() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema> Array::Builder::disownArraySchemaLatest() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Array::Reader::hasArraySchemasAll() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool Array::Builder::hasArraySchemasAll() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); -} -inline ::tiledb::sm::serialization::capnp:: - Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader - Array::Reader::getArraySchemasAll() const { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - get(_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp:: - Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder - Array::Builder::getArraySchemasAll() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - get(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline -Array::Pipeline::getArraySchemasAll() { - return ::tiledb::sm::serialization::capnp:: - Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>:: - Pipeline(_typeless.getPointerField(3)); -} -#endif // !CAPNP_LITE -inline void Array::Builder::setArraySchemasAll( - ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline ::tiledb::sm::serialization::capnp:: - Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder - Array::Builder::initArraySchemasAll() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - init(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader Array::Reader::getArraySchemasAll() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder Array::Builder::getArraySchemasAll() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline Array::Pipeline::getArraySchemasAll() { + return ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline(_typeless.getPointerField(3)); +} +#endif // !CAPNP_LITE +inline void Array::Builder::setArraySchemasAll( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder Array::Builder::initArraySchemasAll() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void Array::Builder::adoptArraySchemasAll( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>> -Array::Builder::disownArraySchemasAll() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>> Array::Builder::disownArraySchemasAll() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool Array::Reader::hasNonEmptyDomain() const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool Array::Builder::hasNonEmptyDomain() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader -Array::Reader::getNonEmptyDomain() const { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: - get(_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader Array::Reader::getNonEmptyDomain() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder -Array::Builder::getNonEmptyDomain() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: - get(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder Array::Builder::getNonEmptyDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline -Array::Pipeline::getNonEmptyDomain() { - return ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline( - _typeless.getPointerField(4)); +inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline Array::Pipeline::getNonEmptyDomain() { + return ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline(_typeless.getPointerField(4)); } #endif // !CAPNP_LITE -inline void Array::Builder::setNonEmptyDomain( - ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: - set(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); +inline void Array::Builder::setNonEmptyDomain( ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder -Array::Builder::initNonEmptyDomain() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: - init(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder Array::Builder::initNonEmptyDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline void Array::Builder::adoptNonEmptyDomain( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::NonEmptyDomainList>&& - value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: - adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::NonEmptyDomainList> -Array::Builder::disownNonEmptyDomain() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: - disown( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NonEmptyDomainList> Array::Builder::disownNonEmptyDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool Array::Reader::hasArrayMetadata() const { - return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } inline bool Array::Builder::hasArrayMetadata() { - return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader -Array::Reader::getArrayMetadata() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::get( - _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader Array::Reader::getArrayMetadata() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder -Array::Builder::getArrayMetadata() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::get( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder Array::Builder::getArrayMetadata() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline -Array::Pipeline::getArrayMetadata() { - return ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline( - _typeless.getPointerField(5)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline Array::Pipeline::getArrayMetadata() { + return ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline(_typeless.getPointerField(5)); } #endif // !CAPNP_LITE -inline void Array::Builder::setArrayMetadata( - ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::set( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - value); +inline void Array::Builder::setArrayMetadata( ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder -Array::Builder::initArrayMetadata() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::init( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder Array::Builder::initArrayMetadata() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } inline void Array::Builder::adoptArrayMetadata( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata>&& - value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::adopt( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata> -Array::Builder::disownArrayMetadata() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::disown( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata> Array::Builder::disownArrayMetadata() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool Array::Reader::hasArrayDirectory() const { - return !_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); } inline bool Array::Builder::hasArrayDirectory() { - return !_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Reader -Array::Reader::getArrayDirectory() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayDirectory>::get( - _reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Reader Array::Reader::getArrayDirectory() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayDirectory>::get(_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Builder -Array::Builder::getArrayDirectory() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayDirectory>::get( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Builder Array::Builder::getArrayDirectory() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayDirectory>::get(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Pipeline -Array::Pipeline::getArrayDirectory() { - return ::tiledb::sm::serialization::capnp::ArrayDirectory::Pipeline( - _typeless.getPointerField(6)); +inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Pipeline Array::Pipeline::getArrayDirectory() { + return ::tiledb::sm::serialization::capnp::ArrayDirectory::Pipeline(_typeless.getPointerField(6)); } #endif // !CAPNP_LITE -inline void Array::Builder::setArrayDirectory( - ::tiledb::sm::serialization::capnp::ArrayDirectory::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayDirectory>::set( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - value); +inline void Array::Builder::setArrayDirectory( ::tiledb::sm::serialization::capnp::ArrayDirectory::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayDirectory>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Builder -Array::Builder::initArrayDirectory() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayDirectory>::init( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Builder Array::Builder::initArrayDirectory() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayDirectory>::init(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); } inline void Array::Builder::adoptArrayDirectory( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayDirectory>&& - value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayDirectory>::adopt( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayDirectory>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayDirectory>::adopt(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayDirectory> -Array::Builder::disownArrayDirectory() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::ArrayDirectory>:: - disown( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayDirectory> Array::Builder::disownArrayDirectory() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayDirectory>::disown(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); } inline bool Array::Reader::hasFragmentMetadataAll() const { - return !_reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); } inline bool Array::Builder::hasFragmentMetadataAll() { - return !_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>::Reader -Array::Reader::getFragmentMetadataAll() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<7>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>::Builder -Array::Builder::getFragmentMetadataAll() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<7>() * - ::capnp::POINTERS)); -} -inline void Array::Builder::setFragmentMetadataAll( - ::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>::Builder -Array::Builder::initFragmentMetadataAll(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>::Reader Array::Reader::getFragmentMetadataAll() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>::Builder Array::Builder::getFragmentMetadataAll() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline void Array::Builder::setFragmentMetadataAll( ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>::Builder Array::Builder::initFragmentMetadataAll(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), size); } inline void Array::Builder::adoptFragmentMetadataAll( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>> -Array::Builder::disownFragmentMetadataAll() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentMetadata, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<7>() * - ::capnp::POINTERS)); -} - -inline ::uint64_t Array::Reader::getOpenedAtEndTimestamp() const { - return _reader.getDataField<::uint64_t>( + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>> Array::Builder::disownFragmentMetadataAll() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} + +inline ::uint64_t Array::Reader::getOpenedAtEndTimestamp() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t Array::Builder::getOpenedAtEndTimestamp() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t Array::Builder::getOpenedAtEndTimestamp() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void Array::Builder::setOpenedAtEndTimestamp(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void Array::Builder::setOpenedAtEndTimestamp( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool ArrayOpen::Reader::hasConfig() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ArrayOpen::Builder::hasConfig() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader -ArrayOpen::Reader::getConfig() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader ArrayOpen::Reader::getConfig() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -ArrayOpen::Builder::getConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayOpen::Builder::getConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline -ArrayOpen::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline ArrayOpen::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void ArrayOpen::Builder::setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void ArrayOpen::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -ArrayOpen::Builder::initConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayOpen::Builder::initConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void ArrayOpen::Builder::adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> -ArrayOpen::Builder::disownConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> ArrayOpen::Builder::disownConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ArrayOpen::Reader::hasQueryType() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool ArrayOpen::Builder::hasQueryType() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader ArrayOpen::Reader::getQueryType() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ArrayOpen::Reader::getQueryType() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ArrayOpen::Builder::getQueryType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ArrayOpen::Builder::getQueryType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void ArrayOpen::Builder::setQueryType(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void ArrayOpen::Builder::setQueryType( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder ArrayOpen::Builder::initQueryType( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder ArrayOpen::Builder::initQueryType(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void ArrayOpen::Builder::adoptQueryType( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> ArrayOpen::Builder::disownQueryType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> ArrayOpen::Builder::disownQueryType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasArrayType() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchema::Builder::hasArrayType() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader ArraySchema::Reader::getArrayType() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ArraySchema::Reader::getArrayType() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ArraySchema::Builder::getArrayType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ArraySchema::Builder::getArrayType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void ArraySchema::Builder::setArrayType(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void ArraySchema::Builder::setArrayType( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder ArraySchema::Builder::initArrayType( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder ArraySchema::Builder::initArrayType(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void ArraySchema::Builder::adoptArrayType( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> ArraySchema::Builder::disownArrayType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> ArraySchema::Builder::disownArrayType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasAttributes() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchema::Builder::hasAttributes() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>::Reader -ArraySchema::Reader::getAttributes() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>::Builder -ArraySchema::Builder::getAttributes() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline void ArraySchema::Builder::setAttributes( - ::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>::Builder -ArraySchema::Builder::initAttributes(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline void ArraySchema::Builder::adoptAttributes( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>> -ArraySchema::Builder::disownAttributes() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} - -inline ::uint64_t ArraySchema::Reader::getCapacity() const { - return _reader.getDataField<::uint64_t>( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Reader ArraySchema::Reader::getAttributes() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } - -inline ::uint64_t ArraySchema::Builder::getCapacity() { - return _builder.getDataField<::uint64_t>( +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Builder ArraySchema::Builder::getAttributes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void ArraySchema::Builder::setAttributes( ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Builder ArraySchema::Builder::initAttributes(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void ArraySchema::Builder::adoptAttributes( + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>> ArraySchema::Builder::disownAttributes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline ::uint64_t ArraySchema::Reader::getCapacity() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t ArraySchema::Builder::getCapacity() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ArraySchema::Builder::setCapacity(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void ArraySchema::Builder::setCapacity( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool ArraySchema::Reader::hasCellOrder() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchema::Builder::hasCellOrder() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader ArraySchema::Reader::getCellOrder() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ArraySchema::Reader::getCellOrder() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ArraySchema::Builder::getCellOrder() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ArraySchema::Builder::getCellOrder() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void ArraySchema::Builder::setCellOrder(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void ArraySchema::Builder::setCellOrder( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder ArraySchema::Builder::initCellOrder( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder ArraySchema::Builder::initCellOrder(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void ArraySchema::Builder::adoptCellOrder( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> ArraySchema::Builder::disownCellOrder() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> ArraySchema::Builder::disownCellOrder() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasCoordsFilterPipeline() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchema::Builder::hasCoordsFilterPipeline() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader -ArraySchema::Reader::getCoordsFilterPipeline() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader ArraySchema::Reader::getCoordsFilterPipeline() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder -ArraySchema::Builder::getCoordsFilterPipeline() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder ArraySchema::Builder::getCoordsFilterPipeline() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline -ArraySchema::Pipeline::getCoordsFilterPipeline() { - return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline( - _typeless.getPointerField(3)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline ArraySchema::Pipeline::getCoordsFilterPipeline() { + return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline(_typeless.getPointerField(3)); } #endif // !CAPNP_LITE -inline void ArraySchema::Builder::setCoordsFilterPipeline( - ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); +inline void ArraySchema::Builder::setCoordsFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder -ArraySchema::Builder::initCoordsFilterPipeline() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder ArraySchema::Builder::initCoordsFilterPipeline() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void ArraySchema::Builder::adoptCoordsFilterPipeline( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& - value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> -ArraySchema::Builder::disownCoordsFilterPipeline() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::FilterPipeline>:: - disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> ArraySchema::Builder::disownCoordsFilterPipeline() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasDomain() const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchema::Builder::hasDomain() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Domain::Reader -ArraySchema::Reader::getDomain() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Domain>::get( - _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Domain::Reader ArraySchema::Reader::getDomain() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Domain>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Domain::Builder -ArraySchema::Builder::getDomain() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Domain>::get( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Domain::Builder ArraySchema::Builder::getDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Domain>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Domain::Pipeline -ArraySchema::Pipeline::getDomain() { - return ::tiledb::sm::serialization::capnp::Domain::Pipeline( - _typeless.getPointerField(4)); +inline ::tiledb::sm::serialization::capnp::Domain::Pipeline ArraySchema::Pipeline::getDomain() { + return ::tiledb::sm::serialization::capnp::Domain::Pipeline(_typeless.getPointerField(4)); } #endif // !CAPNP_LITE -inline void ArraySchema::Builder::setDomain( - ::tiledb::sm::serialization::capnp::Domain::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Domain>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); +inline void ArraySchema::Builder::setDomain( ::tiledb::sm::serialization::capnp::Domain::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Domain>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Domain::Builder -ArraySchema::Builder::initDomain() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Domain>::init( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Domain::Builder ArraySchema::Builder::initDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Domain>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline void ArraySchema::Builder::adoptDomain( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Domain>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Domain>::adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Domain>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Domain>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Domain> -ArraySchema::Builder::disownDomain() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Domain>::disown( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Domain> ArraySchema::Builder::disownDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Domain>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasOffsetFilterPipeline() const { - return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchema::Builder::hasOffsetFilterPipeline() { - return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader -ArraySchema::Reader::getOffsetFilterPipeline() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( - _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader ArraySchema::Reader::getOffsetFilterPipeline() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder -ArraySchema::Builder::getOffsetFilterPipeline() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder ArraySchema::Builder::getOffsetFilterPipeline() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline -ArraySchema::Pipeline::getOffsetFilterPipeline() { - return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline( - _typeless.getPointerField(5)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline ArraySchema::Pipeline::getOffsetFilterPipeline() { + return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline(_typeless.getPointerField(5)); } #endif // !CAPNP_LITE -inline void ArraySchema::Builder::setOffsetFilterPipeline( - ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::set( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - value); +inline void ArraySchema::Builder::setOffsetFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder -ArraySchema::Builder::initOffsetFilterPipeline() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::init( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder ArraySchema::Builder::initOffsetFilterPipeline() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } inline void ArraySchema::Builder::adoptOffsetFilterPipeline( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& - value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::adopt( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> -ArraySchema::Builder::disownOffsetFilterPipeline() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::FilterPipeline>:: - disown( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> ArraySchema::Builder::disownOffsetFilterPipeline() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasTileOrder() const { - return !_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchema::Builder::hasTileOrder() { - return !_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader ArraySchema::Reader::getTileOrder() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ArraySchema::Reader::getTileOrder() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ArraySchema::Builder::getTileOrder() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ArraySchema::Builder::getTileOrder() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); } -inline void ArraySchema::Builder::setTileOrder(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - value); +inline void ArraySchema::Builder::setTileOrder( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder ArraySchema::Builder::initTileOrder( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder ArraySchema::Builder::initTileOrder(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), size); } inline void ArraySchema::Builder::adoptTileOrder( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> ArraySchema::Builder::disownTileOrder() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> ArraySchema::Builder::disownTileOrder() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasUri() const { - return !_reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchema::Builder::hasUri() { - return !_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader ArraySchema::Reader::getUri() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ArraySchema::Reader::getUri() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ArraySchema::Builder::getUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ArraySchema::Builder::getUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); } -inline void ArraySchema::Builder::setUri(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - value); +inline void ArraySchema::Builder::setUri( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder ArraySchema::Builder::initUri(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder ArraySchema::Builder::initUri(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), size); } inline void ArraySchema::Builder::adoptUri( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> ArraySchema::Builder::disownUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> ArraySchema::Builder::disownUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasVersion() const { - return !_reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchema::Builder::hasVersion() { - return !_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Reader -ArraySchema::Reader::getVersion() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Builder -ArraySchema::Builder::getVersion() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); -} -inline void ArraySchema::Builder::setVersion( - ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - value); -} -inline void ArraySchema::Builder::setVersion( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Builder -ArraySchema::Builder::initVersion(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader ArraySchema::Reader::getVersion() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder ArraySchema::Builder::getVersion() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline void ArraySchema::Builder::setVersion( ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline void ArraySchema::Builder::setVersion(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder ArraySchema::Builder::initVersion(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), size); } inline void ArraySchema::Builder::adoptVersion( - ::capnp::Orphan<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::adopt( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>> -ArraySchema::Builder::disownVersion() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>> ArraySchema::Builder::disownVersion() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::getAllowsDuplicates() const { - return _reader.getDataField(::capnp::bounded<64>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<64>() * ::capnp::ELEMENTS); } inline bool ArraySchema::Builder::getAllowsDuplicates() { @@ -18156,653 +13861,458 @@ inline void ArraySchema::Builder::setAllowsDuplicates(bool value) { } inline bool ArraySchema::Reader::hasValidityFilterPipeline() const { - return !_reader.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchema::Builder::hasValidityFilterPipeline() { - return !_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader -ArraySchema::Reader::getValidityFilterPipeline() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( - _reader.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader ArraySchema::Reader::getValidityFilterPipeline() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder -ArraySchema::Builder::getValidityFilterPipeline() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( - _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder ArraySchema::Builder::getValidityFilterPipeline() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline -ArraySchema::Pipeline::getValidityFilterPipeline() { - return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline( - _typeless.getPointerField(9)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline ArraySchema::Pipeline::getValidityFilterPipeline() { + return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline(_typeless.getPointerField(9)); } #endif // !CAPNP_LITE -inline void ArraySchema::Builder::setValidityFilterPipeline( - ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::set( - _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), - value); +inline void ArraySchema::Builder::setValidityFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::set(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder -ArraySchema::Builder::initValidityFilterPipeline() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::init( - _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder ArraySchema::Builder::initValidityFilterPipeline() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::init(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); } inline void ArraySchema::Builder::adoptValidityFilterPipeline( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& - value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::adopt( - _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::adopt(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> -ArraySchema::Builder::disownValidityFilterPipeline() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::FilterPipeline>:: - disown( - _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> ArraySchema::Builder::disownValidityFilterPipeline() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::disown(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasName() const { - return !_reader.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchema::Builder::hasName() { - return !_builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader ArraySchema::Reader::getName() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ArraySchema::Reader::getName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ArraySchema::Builder::getName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ArraySchema::Builder::getName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); } -inline void ArraySchema::Builder::setName(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), - value); +inline void ArraySchema::Builder::setName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder ArraySchema::Builder::initName( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder ArraySchema::Builder::initName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), size); } inline void ArraySchema::Builder::adoptName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> ArraySchema::Builder::disownName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> ArraySchema::Builder::disownName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasTimestampRange() const { - return !_reader.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchema::Builder::hasTimestampRange() { - return !_builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -ArraySchema::Reader::getTimestampRange() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -ArraySchema::Builder::getTimestampRange() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS)); -} -inline void ArraySchema::Builder::setTimestampRange( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), - value); -} -inline void ArraySchema::Builder::setTimestampRange( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -ArraySchema::Builder::initTimestampRange(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader ArraySchema::Reader::getTimestampRange() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder ArraySchema::Builder::getTimestampRange() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} +inline void ArraySchema::Builder::setTimestampRange( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), value); +} +inline void ArraySchema::Builder::setTimestampRange(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder ArraySchema::Builder::initTimestampRange(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), size); } inline void ArraySchema::Builder::adoptTimestampRange( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -ArraySchema::Builder::disownTimestampRange() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> ArraySchema::Builder::disownTimestampRange() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasDimensionLabels() const { - return !_reader.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchema::Builder::hasDimensionLabels() { - return !_builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>::Reader -ArraySchema::Reader::getDimensionLabels() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<12>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>::Builder -ArraySchema::Builder::getDimensionLabels() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<12>() * - ::capnp::POINTERS)); -} -inline void ArraySchema::Builder::setDimensionLabels( - ::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>::Builder -ArraySchema::Builder::initDimensionLabels(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>::Reader ArraySchema::Reader::getDimensionLabels() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>::Builder ArraySchema::Builder::getDimensionLabels() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); +} +inline void ArraySchema::Builder::setDimensionLabels( ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>::Builder ArraySchema::Builder::initDimensionLabels(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), size); } inline void ArraySchema::Builder::adoptDimensionLabels( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>> -ArraySchema::Builder::disownDimensionLabels() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::DimensionLabel, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<12>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>> ArraySchema::Builder::disownDimensionLabels() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasEnumerations() const { - return !_reader.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchema::Builder::hasEnumerations() { - return !_builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader -ArraySchema::Reader::getEnumerations() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<13>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder -ArraySchema::Builder::getEnumerations() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<13>() * - ::capnp::POINTERS)); -} -inline void ArraySchema::Builder::setEnumerations( - ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder -ArraySchema::Builder::initEnumerations(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader ArraySchema::Reader::getEnumerations() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder ArraySchema::Builder::getEnumerations() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); +} +inline void ArraySchema::Builder::setEnumerations( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder ArraySchema::Builder::initEnumerations(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), size); } inline void ArraySchema::Builder::adoptEnumerations( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>> -ArraySchema::Builder::disownEnumerations() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<13>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> ArraySchema::Builder::disownEnumerations() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasEnumerationPathMap() const { - return !_reader.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchema::Builder::hasEnumerationPathMap() { - return !_builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp:: - List<::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader - ArraySchema::Reader::getEnumerationPathMap() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<14>() * - ::capnp::POINTERS)); -} -inline ::capnp:: - List<::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder - ArraySchema::Builder::getEnumerationPathMap() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<14>() * - ::capnp::POINTERS)); -} -inline void ArraySchema::Builder::setEnumerationPathMap( - ::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), - value); -} -inline ::capnp:: - List<::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder - ArraySchema::Builder::initEnumerationPathMap(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader ArraySchema::Reader::getEnumerationPathMap() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder ArraySchema::Builder::getEnumerationPathMap() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); +} +inline void ArraySchema::Builder::setEnumerationPathMap( ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder ArraySchema::Builder::initEnumerationPathMap(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), size); } inline void ArraySchema::Builder::adoptEnumerationPathMap( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>> -ArraySchema::Builder::disownEnumerationPathMap() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::KV, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<14>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>> ArraySchema::Builder::disownEnumerationPathMap() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasCurrentDomain() const { - return !_reader.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchema::Builder::hasCurrentDomain() { - return !_builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Reader -ArraySchema::Reader::getCurrentDomain() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::get( - _reader.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Reader ArraySchema::Reader::getCurrentDomain() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::get(_reader.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder -ArraySchema::Builder::getCurrentDomain() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::get( - _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder ArraySchema::Builder::getCurrentDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::get(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline -ArraySchema::Pipeline::getCurrentDomain() { - return ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline( - _typeless.getPointerField(15)); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline ArraySchema::Pipeline::getCurrentDomain() { + return ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline(_typeless.getPointerField(15)); } #endif // !CAPNP_LITE -inline void ArraySchema::Builder::setCurrentDomain( - ::tiledb::sm::serialization::capnp::CurrentDomain::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::set( - _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS), - value); +inline void ArraySchema::Builder::setCurrentDomain( ::tiledb::sm::serialization::capnp::CurrentDomain::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::set(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder -ArraySchema::Builder::initCurrentDomain() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::init( - _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder ArraySchema::Builder::initCurrentDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::init(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); } inline void ArraySchema::Builder::adoptCurrentDomain( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::CurrentDomain>&& - value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::adopt( - _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::CurrentDomain> -ArraySchema::Builder::disownCurrentDomain() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::disown( - _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS)); -} - -inline ::uint32_t DimensionLabel::Reader::getDimensionId() const { - return _reader.getDataField<::uint32_t>( + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::CurrentDomain>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::adopt(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::CurrentDomain> ArraySchema::Builder::disownCurrentDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::disown(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); +} + +inline ::uint32_t DimensionLabel::Reader::getDimensionId() const { + return _reader.getDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint32_t DimensionLabel::Builder::getDimensionId() { - return _builder.getDataField<::uint32_t>( +inline ::uint32_t DimensionLabel::Builder::getDimensionId() { + return _builder.getDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void DimensionLabel::Builder::setDimensionId(::uint32_t value) { - _builder.setDataField<::uint32_t>( +inline void DimensionLabel::Builder::setDimensionId( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool DimensionLabel::Reader::hasName() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool DimensionLabel::Builder::hasName() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader DimensionLabel::Reader::getName() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader DimensionLabel::Reader::getName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder DimensionLabel::Builder::getName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder DimensionLabel::Builder::getName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void DimensionLabel::Builder::setName(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void DimensionLabel::Builder::setName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder DimensionLabel::Builder::initName( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder DimensionLabel::Builder::initName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void DimensionLabel::Builder::adoptName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> DimensionLabel::Builder::disownName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> DimensionLabel::Builder::disownName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool DimensionLabel::Reader::hasUri() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool DimensionLabel::Builder::hasUri() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader DimensionLabel::Reader::getUri() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader DimensionLabel::Reader::getUri() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder DimensionLabel::Builder::getUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder DimensionLabel::Builder::getUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void DimensionLabel::Builder::setUri(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void DimensionLabel::Builder::setUri( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder DimensionLabel::Builder::initUri( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder DimensionLabel::Builder::initUri(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void DimensionLabel::Builder::adoptUri( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> DimensionLabel::Builder::disownUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> DimensionLabel::Builder::disownUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool DimensionLabel::Reader::hasAttributeName() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool DimensionLabel::Builder::hasAttributeName() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader DimensionLabel::Reader::getAttributeName() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader DimensionLabel::Reader::getAttributeName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder DimensionLabel::Builder::getAttributeName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder DimensionLabel::Builder::getAttributeName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void DimensionLabel::Builder::setAttributeName( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void DimensionLabel::Builder::setAttributeName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder DimensionLabel::Builder::initAttributeName( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder DimensionLabel::Builder::initAttributeName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void DimensionLabel::Builder::adoptAttributeName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -DimensionLabel::Builder::disownAttributeName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> DimensionLabel::Builder::disownAttributeName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool DimensionLabel::Reader::hasOrder() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool DimensionLabel::Builder::hasOrder() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader DimensionLabel::Reader::getOrder() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader DimensionLabel::Reader::getOrder() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder DimensionLabel::Builder::getOrder() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder DimensionLabel::Builder::getOrder() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline void DimensionLabel::Builder::setOrder(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); +inline void DimensionLabel::Builder::setOrder( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder DimensionLabel::Builder::initOrder( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder DimensionLabel::Builder::initOrder(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); } inline void DimensionLabel::Builder::adoptOrder( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> DimensionLabel::Builder::disownOrder() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> DimensionLabel::Builder::disownOrder() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool DimensionLabel::Reader::hasType() const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool DimensionLabel::Builder::hasType() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader DimensionLabel::Reader::getType() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader DimensionLabel::Reader::getType() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder DimensionLabel::Builder::getType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder DimensionLabel::Builder::getType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline void DimensionLabel::Builder::setType(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); +inline void DimensionLabel::Builder::setType( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder DimensionLabel::Builder::initType( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder DimensionLabel::Builder::initType(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); } inline void DimensionLabel::Builder::adoptType( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> DimensionLabel::Builder::disownType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> DimensionLabel::Builder::disownType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::uint32_t DimensionLabel::Reader::getCellValNum() const { - return _reader.getDataField<::uint32_t>( +inline ::uint32_t DimensionLabel::Reader::getCellValNum() const { + return _reader.getDataField< ::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint32_t DimensionLabel::Builder::getCellValNum() { - return _builder.getDataField<::uint32_t>( +inline ::uint32_t DimensionLabel::Builder::getCellValNum() { + return _builder.getDataField< ::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void DimensionLabel::Builder::setCellValNum(::uint32_t value) { - _builder.setDataField<::uint32_t>( +inline void DimensionLabel::Builder::setCellValNum( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool DimensionLabel::Reader::getExternal() const { - return _reader.getDataField(::capnp::bounded<64>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<64>() * ::capnp::ELEMENTS); } inline bool DimensionLabel::Builder::getExternal() { @@ -18815,7 +14325,8 @@ inline void DimensionLabel::Builder::setExternal(bool value) { } inline bool DimensionLabel::Reader::getRelative() const { - return _reader.getDataField(::capnp::bounded<65>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<65>() * ::capnp::ELEMENTS); } inline bool DimensionLabel::Builder::getRelative() { @@ -18828,689 +14339,457 @@ inline void DimensionLabel::Builder::setRelative(bool value) { } inline bool DimensionLabel::Reader::hasSchema() const { - return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } inline bool DimensionLabel::Builder::hasSchema() { - return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader -DimensionLabel::Reader::getSchema() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::get( - _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader DimensionLabel::Reader::getSchema() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder -DimensionLabel::Builder::getSchema() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::get( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder DimensionLabel::Builder::getSchema() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline -DimensionLabel::Pipeline::getSchema() { - return ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline( - _typeless.getPointerField(5)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline DimensionLabel::Pipeline::getSchema() { + return ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline(_typeless.getPointerField(5)); } #endif // !CAPNP_LITE -inline void DimensionLabel::Builder::setSchema( - ::tiledb::sm::serialization::capnp::ArraySchema::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>:: - set(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - value); +inline void DimensionLabel::Builder::setSchema( ::tiledb::sm::serialization::capnp::ArraySchema::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder -DimensionLabel::Builder::initSchema() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::init( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder DimensionLabel::Builder::initSchema() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } inline void DimensionLabel::Builder::adoptSchema( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>:: - adopt( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema> -DimensionLabel::Builder::disownSchema() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::disown( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema> DimensionLabel::Builder::disownSchema() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool ArraySchemaEvolution::Reader::hasAttributesToDrop() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchemaEvolution::Builder::hasAttributesToDrop() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -ArraySchemaEvolution::Reader::getAttributesToDrop() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArraySchemaEvolution::Builder::getAttributesToDrop() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void ArraySchemaEvolution::Builder::setAttributesToDrop( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline void ArraySchemaEvolution::Builder::setAttributesToDrop( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArraySchemaEvolution::Builder::initAttributesToDrop(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArraySchemaEvolution::Reader::getAttributesToDrop() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArraySchemaEvolution::Builder::getAttributesToDrop() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void ArraySchemaEvolution::Builder::setAttributesToDrop( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline void ArraySchemaEvolution::Builder::setAttributesToDrop(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArraySchemaEvolution::Builder::initAttributesToDrop(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void ArraySchemaEvolution::Builder::adoptAttributesToDrop( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -ArraySchemaEvolution::Builder::disownAttributesToDrop() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArraySchemaEvolution::Builder::disownAttributesToDrop() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ArraySchemaEvolution::Reader::hasAttributesToAdd() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchemaEvolution::Builder::hasAttributesToAdd() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>::Reader -ArraySchemaEvolution::Reader::getAttributesToAdd() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>::Builder -ArraySchemaEvolution::Builder::getAttributesToAdd() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline void ArraySchemaEvolution::Builder::setAttributesToAdd( - ::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>::Builder -ArraySchemaEvolution::Builder::initAttributesToAdd(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Reader ArraySchemaEvolution::Reader::getAttributesToAdd() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Builder ArraySchemaEvolution::Builder::getAttributesToAdd() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void ArraySchemaEvolution::Builder::setAttributesToAdd( ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Builder ArraySchemaEvolution::Builder::initAttributesToAdd(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void ArraySchemaEvolution::Builder::adoptAttributesToAdd( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>> -ArraySchemaEvolution::Builder::disownAttributesToAdd() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Attribute, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>> ArraySchemaEvolution::Builder::disownAttributesToAdd() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool ArraySchemaEvolution::Reader::hasTimestampRange() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchemaEvolution::Builder::hasTimestampRange() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -ArraySchemaEvolution::Reader::getTimestampRange() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -ArraySchemaEvolution::Builder::getTimestampRange() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void ArraySchemaEvolution::Builder::setTimestampRange( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline void ArraySchemaEvolution::Builder::setTimestampRange( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -ArraySchemaEvolution::Builder::initTimestampRange(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader ArraySchemaEvolution::Reader::getTimestampRange() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder ArraySchemaEvolution::Builder::getTimestampRange() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void ArraySchemaEvolution::Builder::setTimestampRange( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline void ArraySchemaEvolution::Builder::setTimestampRange(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder ArraySchemaEvolution::Builder::initTimestampRange(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void ArraySchemaEvolution::Builder::adoptTimestampRange( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -ArraySchemaEvolution::Builder::disownTimestampRange() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> ArraySchemaEvolution::Builder::disownTimestampRange() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool ArraySchemaEvolution::Reader::hasEnumerationsToAdd() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchemaEvolution::Builder::hasEnumerationsToAdd() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader -ArraySchemaEvolution::Reader::getEnumerationsToAdd() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<3>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder -ArraySchemaEvolution::Builder::getEnumerationsToAdd() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<3>() * - ::capnp::POINTERS)); -} -inline void ArraySchemaEvolution::Builder::setEnumerationsToAdd( - ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder -ArraySchemaEvolution::Builder::initEnumerationsToAdd(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader ArraySchemaEvolution::Reader::getEnumerationsToAdd() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder ArraySchemaEvolution::Builder::getEnumerationsToAdd() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void ArraySchemaEvolution::Builder::setEnumerationsToAdd( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder ArraySchemaEvolution::Builder::initEnumerationsToAdd(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); } inline void ArraySchemaEvolution::Builder::adoptEnumerationsToAdd( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>> -ArraySchemaEvolution::Builder::disownEnumerationsToAdd() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<3>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> ArraySchemaEvolution::Builder::disownEnumerationsToAdd() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool ArraySchemaEvolution::Reader::hasEnumerationsToDrop() const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchemaEvolution::Builder::hasEnumerationsToDrop() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -ArraySchemaEvolution::Reader::getEnumerationsToDrop() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArraySchemaEvolution::Builder::getEnumerationsToDrop() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline void ArraySchemaEvolution::Builder::setEnumerationsToDrop( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); -} -inline void ArraySchemaEvolution::Builder::setEnumerationsToDrop( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArraySchemaEvolution::Builder::initEnumerationsToDrop(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArraySchemaEvolution::Reader::getEnumerationsToDrop() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArraySchemaEvolution::Builder::getEnumerationsToDrop() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void ArraySchemaEvolution::Builder::setEnumerationsToDrop( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline void ArraySchemaEvolution::Builder::setEnumerationsToDrop(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArraySchemaEvolution::Builder::initEnumerationsToDrop(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); } inline void ArraySchemaEvolution::Builder::adoptEnumerationsToDrop( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -ArraySchemaEvolution::Builder::disownEnumerationsToDrop() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArraySchemaEvolution::Builder::disownEnumerationsToDrop() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool ArraySchemaEvolution::Reader::hasEnumerationsToExtend() const { - return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchemaEvolution::Builder::hasEnumerationsToExtend() { - return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader -ArraySchemaEvolution::Reader::getEnumerationsToExtend() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<5>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder -ArraySchemaEvolution::Builder::getEnumerationsToExtend() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<5>() * - ::capnp::POINTERS)); -} -inline void ArraySchemaEvolution::Builder::setEnumerationsToExtend( - ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder -ArraySchemaEvolution::Builder::initEnumerationsToExtend(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader ArraySchemaEvolution::Reader::getEnumerationsToExtend() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder ArraySchemaEvolution::Builder::getEnumerationsToExtend() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline void ArraySchemaEvolution::Builder::setEnumerationsToExtend( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder ArraySchemaEvolution::Builder::initEnumerationsToExtend(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), size); } inline void ArraySchemaEvolution::Builder::adoptEnumerationsToExtend( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>> -ArraySchemaEvolution::Builder::disownEnumerationsToExtend() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<5>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> ArraySchemaEvolution::Builder::disownEnumerationsToExtend() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool ArraySchemaEvolution::Reader::hasCurrentDomainToExpand() const { - return !_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); } inline bool ArraySchemaEvolution::Builder::hasCurrentDomainToExpand() { - return !_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Reader -ArraySchemaEvolution::Reader::getCurrentDomainToExpand() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::get( - _reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Reader ArraySchemaEvolution::Reader::getCurrentDomainToExpand() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::get(_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder -ArraySchemaEvolution::Builder::getCurrentDomainToExpand() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::get( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder ArraySchemaEvolution::Builder::getCurrentDomainToExpand() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::get(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline -ArraySchemaEvolution::Pipeline::getCurrentDomainToExpand() { - return ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline( - _typeless.getPointerField(6)); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline ArraySchemaEvolution::Pipeline::getCurrentDomainToExpand() { + return ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline(_typeless.getPointerField(6)); } #endif // !CAPNP_LITE -inline void ArraySchemaEvolution::Builder::setCurrentDomainToExpand( - ::tiledb::sm::serialization::capnp::CurrentDomain::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::set( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - value); +inline void ArraySchemaEvolution::Builder::setCurrentDomainToExpand( ::tiledb::sm::serialization::capnp::CurrentDomain::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder -ArraySchemaEvolution::Builder::initCurrentDomainToExpand() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::init( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder ArraySchemaEvolution::Builder::initCurrentDomainToExpand() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::init(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); } inline void ArraySchemaEvolution::Builder::adoptCurrentDomainToExpand( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::CurrentDomain>&& - value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::adopt( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::CurrentDomain> -ArraySchemaEvolution::Builder::disownCurrentDomainToExpand() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::disown( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); -} - -inline ::uint32_t Attribute::Reader::getCellValNum() const { - return _reader.getDataField<::uint32_t>( + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::CurrentDomain>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::adopt(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::CurrentDomain> ArraySchemaEvolution::Builder::disownCurrentDomainToExpand() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::disown(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} + +inline ::uint32_t Attribute::Reader::getCellValNum() const { + return _reader.getDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint32_t Attribute::Builder::getCellValNum() { - return _builder.getDataField<::uint32_t>( +inline ::uint32_t Attribute::Builder::getCellValNum() { + return _builder.getDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void Attribute::Builder::setCellValNum(::uint32_t value) { - _builder.setDataField<::uint32_t>( +inline void Attribute::Builder::setCellValNum( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool Attribute::Reader::hasName() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool Attribute::Builder::hasName() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Attribute::Reader::getName() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Attribute::Reader::getName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Attribute::Builder::getName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Attribute::Builder::getName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Attribute::Builder::setName(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void Attribute::Builder::setName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Attribute::Builder::initName(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Attribute::Builder::initName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void Attribute::Builder::adoptName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Attribute::Builder::disownName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Attribute::Builder::disownName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Attribute::Reader::hasType() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool Attribute::Builder::hasType() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Attribute::Reader::getType() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Attribute::Reader::getType() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Attribute::Builder::getType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Attribute::Builder::getType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void Attribute::Builder::setType(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void Attribute::Builder::setType( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Attribute::Builder::initType(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Attribute::Builder::initType(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void Attribute::Builder::adoptType( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Attribute::Builder::disownType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Attribute::Builder::disownType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Attribute::Reader::hasFilterPipeline() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool Attribute::Builder::hasFilterPipeline() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader -Attribute::Reader::getFilterPipeline() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader Attribute::Reader::getFilterPipeline() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder -Attribute::Builder::getFilterPipeline() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder Attribute::Builder::getFilterPipeline() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline -Attribute::Pipeline::getFilterPipeline() { - return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline( - _typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline Attribute::Pipeline::getFilterPipeline() { + return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline(_typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void Attribute::Builder::setFilterPipeline( - ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void Attribute::Builder::setFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder -Attribute::Builder::initFilterPipeline() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder Attribute::Builder::initFilterPipeline() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void Attribute::Builder::adoptFilterPipeline( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& - value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> -Attribute::Builder::disownFilterPipeline() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::FilterPipeline>:: - disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> Attribute::Builder::disownFilterPipeline() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Attribute::Reader::hasFillValue() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool Attribute::Builder::hasFillValue() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Data::Reader Attribute::Reader::getFillValue() const { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Data::Reader Attribute::Reader::getFillValue() const { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::capnp::Data::Builder Attribute::Builder::getFillValue() { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Data::Builder Attribute::Builder::getFillValue() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline void Attribute::Builder::setFillValue(::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Data>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); +inline void Attribute::Builder::setFillValue( ::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); } -inline ::capnp::Data::Builder Attribute::Builder::initFillValue( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Data>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - size); +inline ::capnp::Data::Builder Attribute::Builder::initFillValue(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); } inline void Attribute::Builder::adoptFillValue( - ::capnp::Orphan<::capnp::Data>&& value) { - ::capnp::_::PointerHelpers<::capnp::Data>::adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Data>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Data> Attribute::Builder::disownFillValue() { - return ::capnp::_::PointerHelpers<::capnp::Data>::disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Data> Attribute::Builder::disownFillValue() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool Attribute::Reader::getNullable() const { - return _reader.getDataField(::capnp::bounded<32>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<32>() * ::capnp::ELEMENTS); } inline bool Attribute::Builder::getNullable() { @@ -19523,7 +14802,8 @@ inline void Attribute::Builder::setNullable(bool value) { } inline bool Attribute::Reader::getFillValueValidity() const { - return _reader.getDataField(::capnp::bounded<33>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<33>() * ::capnp::ELEMENTS); } inline bool Attribute::Builder::getFillValueValidity() { @@ -19536,212 +14816,192 @@ inline void Attribute::Builder::setFillValueValidity(bool value) { } inline bool Attribute::Reader::hasOrder() const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool Attribute::Builder::hasOrder() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Attribute::Reader::getOrder() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Attribute::Reader::getOrder() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Attribute::Builder::getOrder() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Attribute::Builder::getOrder() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline void Attribute::Builder::setOrder(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); +inline void Attribute::Builder::setOrder( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Attribute::Builder::initOrder(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Attribute::Builder::initOrder(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); } inline void Attribute::Builder::adoptOrder( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Attribute::Builder::disownOrder() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Attribute::Builder::disownOrder() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool Attribute::Reader::hasEnumerationName() const { - return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } inline bool Attribute::Builder::hasEnumerationName() { - return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Attribute::Reader::getEnumerationName() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Attribute::Reader::getEnumerationName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Attribute::Builder::getEnumerationName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Attribute::Builder::getEnumerationName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline void Attribute::Builder::setEnumerationName( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - value); +inline void Attribute::Builder::setEnumerationName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Attribute::Builder::initEnumerationName( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Attribute::Builder::initEnumerationName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), size); } inline void Attribute::Builder::adoptEnumerationName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -Attribute::Builder::disownEnumerationName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Attribute::Builder::disownEnumerationName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool Enumeration::Reader::hasName() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool Enumeration::Builder::hasName() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Enumeration::Reader::getName() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Enumeration::Reader::getName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Enumeration::Builder::getName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Enumeration::Builder::getName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Enumeration::Builder::setName(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void Enumeration::Builder::setName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Enumeration::Builder::initName( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Enumeration::Builder::initName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void Enumeration::Builder::adoptName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Enumeration::Builder::disownName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Enumeration::Builder::disownName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Enumeration::Reader::hasPathName() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool Enumeration::Builder::hasPathName() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Enumeration::Reader::getPathName() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Enumeration::Reader::getPathName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Enumeration::Builder::getPathName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Enumeration::Builder::getPathName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void Enumeration::Builder::setPathName(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void Enumeration::Builder::setPathName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Enumeration::Builder::initPathName( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Enumeration::Builder::initPathName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void Enumeration::Builder::adoptPathName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Enumeration::Builder::disownPathName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Enumeration::Builder::disownPathName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Enumeration::Reader::hasType() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool Enumeration::Builder::hasType() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Enumeration::Reader::getType() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Enumeration::Reader::getType() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Enumeration::Builder::getType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Enumeration::Builder::getType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void Enumeration::Builder::setType(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void Enumeration::Builder::setType( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Enumeration::Builder::initType( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Enumeration::Builder::initType(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void Enumeration::Builder::adoptType( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Enumeration::Builder::disownType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Enumeration::Builder::disownType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::uint32_t Enumeration::Reader::getCellValNum() const { - return _reader.getDataField<::uint32_t>( +inline ::uint32_t Enumeration::Reader::getCellValNum() const { + return _reader.getDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint32_t Enumeration::Builder::getCellValNum() { - return _builder.getDataField<::uint32_t>( +inline ::uint32_t Enumeration::Builder::getCellValNum() { + return _builder.getDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void Enumeration::Builder::setCellValNum(::uint32_t value) { - _builder.setDataField<::uint32_t>( +inline void Enumeration::Builder::setCellValNum( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool Enumeration::Reader::getOrdered() const { - return _reader.getDataField(::capnp::bounded<32>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<32>() * ::capnp::ELEMENTS); } inline bool Enumeration::Builder::getOrdered() { @@ -19754,450 +15014,374 @@ inline void Enumeration::Builder::setOrdered(bool value) { } inline bool Enumeration::Reader::hasData() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool Enumeration::Builder::hasData() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Data::Reader Enumeration::Reader::getData() const { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Data::Reader Enumeration::Reader::getData() const { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::capnp::Data::Builder Enumeration::Builder::getData() { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Data::Builder Enumeration::Builder::getData() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline void Enumeration::Builder::setData(::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Data>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); +inline void Enumeration::Builder::setData( ::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); } -inline ::capnp::Data::Builder Enumeration::Builder::initData( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Data>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - size); +inline ::capnp::Data::Builder Enumeration::Builder::initData(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); } inline void Enumeration::Builder::adoptData( - ::capnp::Orphan<::capnp::Data>&& value) { - ::capnp::_::PointerHelpers<::capnp::Data>::adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Data>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Data> Enumeration::Builder::disownData() { - return ::capnp::_::PointerHelpers<::capnp::Data>::disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Data> Enumeration::Builder::disownData() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool Enumeration::Reader::hasOffsets() const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool Enumeration::Builder::hasOffsets() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Data::Reader Enumeration::Reader::getOffsets() const { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Data::Reader Enumeration::Reader::getOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::capnp::Data::Builder Enumeration::Builder::getOffsets() { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Data::Builder Enumeration::Builder::getOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline void Enumeration::Builder::setOffsets(::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Data>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); +inline void Enumeration::Builder::setOffsets( ::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); } -inline ::capnp::Data::Builder Enumeration::Builder::initOffsets( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Data>::init( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - size); +inline ::capnp::Data::Builder Enumeration::Builder::initOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); } inline void Enumeration::Builder::adoptOffsets( - ::capnp::Orphan<::capnp::Data>&& value) { - ::capnp::_::PointerHelpers<::capnp::Data>::adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Data>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Data> Enumeration::Builder::disownOffsets() { - return ::capnp::_::PointerHelpers<::capnp::Data>::disown( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Data> Enumeration::Builder::disownOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool AttributeBufferHeader::Reader::hasName() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool AttributeBufferHeader::Builder::hasName() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader AttributeBufferHeader::Reader::getName() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader AttributeBufferHeader::Reader::getName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder AttributeBufferHeader::Builder::getName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder AttributeBufferHeader::Builder::getName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void AttributeBufferHeader::Builder::setName( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void AttributeBufferHeader::Builder::setName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder AttributeBufferHeader::Builder::initName( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder AttributeBufferHeader::Builder::initName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void AttributeBufferHeader::Builder::adoptName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -AttributeBufferHeader::Builder::disownName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> AttributeBufferHeader::Builder::disownName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t AttributeBufferHeader::Reader::getFixedLenBufferSizeInBytes() - const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferHeader::Reader::getFixedLenBufferSizeInBytes() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t -AttributeBufferHeader::Builder::getFixedLenBufferSizeInBytes() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferHeader::Builder::getFixedLenBufferSizeInBytes() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void AttributeBufferHeader::Builder::setFixedLenBufferSizeInBytes( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void AttributeBufferHeader::Builder::setFixedLenBufferSizeInBytes( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t AttributeBufferHeader::Reader::getVarLenBufferSizeInBytes() - const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferHeader::Reader::getVarLenBufferSizeInBytes() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t AttributeBufferHeader::Builder::getVarLenBufferSizeInBytes() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferHeader::Builder::getVarLenBufferSizeInBytes() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void AttributeBufferHeader::Builder::setVarLenBufferSizeInBytes( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void AttributeBufferHeader::Builder::setVarLenBufferSizeInBytes( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t -AttributeBufferHeader::Reader::getValidityLenBufferSizeInBytes() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferHeader::Reader::getValidityLenBufferSizeInBytes() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t -AttributeBufferHeader::Builder::getValidityLenBufferSizeInBytes() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferHeader::Builder::getValidityLenBufferSizeInBytes() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void AttributeBufferHeader::Builder::setValidityLenBufferSizeInBytes( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void AttributeBufferHeader::Builder::setValidityLenBufferSizeInBytes( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t -AttributeBufferHeader::Reader::getOriginalFixedLenBufferSizeInBytes() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferHeader::Reader::getOriginalFixedLenBufferSizeInBytes() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS); } -inline ::uint64_t -AttributeBufferHeader::Builder::getOriginalFixedLenBufferSizeInBytes() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferHeader::Builder::getOriginalFixedLenBufferSizeInBytes() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS); } -inline void -AttributeBufferHeader::Builder::setOriginalFixedLenBufferSizeInBytes( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void AttributeBufferHeader::Builder::setOriginalFixedLenBufferSizeInBytes( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t -AttributeBufferHeader::Reader::getOriginalVarLenBufferSizeInBytes() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferHeader::Reader::getOriginalVarLenBufferSizeInBytes() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS); } -inline ::uint64_t -AttributeBufferHeader::Builder::getOriginalVarLenBufferSizeInBytes() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferHeader::Builder::getOriginalVarLenBufferSizeInBytes() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS); } -inline void AttributeBufferHeader::Builder::setOriginalVarLenBufferSizeInBytes( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void AttributeBufferHeader::Builder::setOriginalVarLenBufferSizeInBytes( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t -AttributeBufferHeader::Reader::getOriginalValidityLenBufferSizeInBytes() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferHeader::Reader::getOriginalValidityLenBufferSizeInBytes() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<5>() * ::capnp::ELEMENTS); } -inline ::uint64_t -AttributeBufferHeader::Builder::getOriginalValidityLenBufferSizeInBytes() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferHeader::Builder::getOriginalValidityLenBufferSizeInBytes() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<5>() * ::capnp::ELEMENTS); } -inline void -AttributeBufferHeader::Builder::setOriginalValidityLenBufferSizeInBytes( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void AttributeBufferHeader::Builder::setOriginalValidityLenBufferSizeInBytes( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<5>() * ::capnp::ELEMENTS, value); } inline bool Dimension::Reader::hasName() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool Dimension::Builder::hasName() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Dimension::Reader::getName() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Dimension::Reader::getName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Dimension::Builder::getName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Dimension::Builder::getName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Dimension::Builder::setName(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void Dimension::Builder::setName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Dimension::Builder::initName(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Dimension::Builder::initName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void Dimension::Builder::adoptName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Dimension::Builder::disownName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Dimension::Builder::disownName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Dimension::Reader::getNullTileExtent() const { - return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool Dimension::Builder::getNullTileExtent() { - return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void Dimension::Builder::setNullTileExtent(bool value) { - _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool Dimension::Reader::hasType() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool Dimension::Builder::hasType() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Dimension::Reader::getType() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Dimension::Reader::getType() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Dimension::Builder::getType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Dimension::Builder::getType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void Dimension::Builder::setType(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void Dimension::Builder::setType( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Dimension::Builder::initType(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Dimension::Builder::initType(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void Dimension::Builder::adoptType( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Dimension::Builder::disownType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Dimension::Builder::disownType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline typename Dimension::TileExtent::Reader Dimension::Reader::getTileExtent() - const { +inline typename Dimension::TileExtent::Reader Dimension::Reader::getTileExtent() const { return typename Dimension::TileExtent::Reader(_reader); } -inline typename Dimension::TileExtent::Builder -Dimension::Builder::getTileExtent() { +inline typename Dimension::TileExtent::Builder Dimension::Builder::getTileExtent() { return typename Dimension::TileExtent::Builder(_builder); } #if !CAPNP_LITE -inline typename Dimension::TileExtent::Pipeline -Dimension::Pipeline::getTileExtent() { +inline typename Dimension::TileExtent::Pipeline Dimension::Pipeline::getTileExtent() { return typename Dimension::TileExtent::Pipeline(_typeless.noop()); } #endif // !CAPNP_LITE -inline typename Dimension::TileExtent::Builder -Dimension::Builder::initTileExtent() { - _builder.setDataField<::uint8_t>( - ::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); - _builder.setDataField<::uint16_t>( - ::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); - _builder.setDataField<::uint32_t>( - ::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); - _builder.setDataField<::uint64_t>( - ::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); +inline typename Dimension::TileExtent::Builder Dimension::Builder::initTileExtent() { + _builder.setDataField< ::uint8_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint32_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); return typename Dimension::TileExtent::Builder(_builder); } inline bool Dimension::Reader::hasDomain() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool Dimension::Builder::hasDomain() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Reader -Dimension::Reader::getDomain() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Reader Dimension::Reader::getDomain() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Builder -Dimension::Builder::getDomain() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Builder Dimension::Builder::getDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline -Dimension::Pipeline::getDomain() { - return ::tiledb::sm::serialization::capnp::DomainArray::Pipeline( - _typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline Dimension::Pipeline::getDomain() { + return ::tiledb::sm::serialization::capnp::DomainArray::Pipeline(_typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void Dimension::Builder::setDomain( - ::tiledb::sm::serialization::capnp::DomainArray::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>:: - set(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void Dimension::Builder::setDomain( ::tiledb::sm::serialization::capnp::DomainArray::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Builder -Dimension::Builder::initDomain() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Builder Dimension::Builder::initDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void Dimension::Builder::adoptDomain( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>:: - adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray> -Dimension::Builder::disownDomain() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray> Dimension::Builder::disownDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Dimension::Reader::hasFilterPipeline() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool Dimension::Builder::hasFilterPipeline() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader -Dimension::Reader::getFilterPipeline() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader Dimension::Reader::getFilterPipeline() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder -Dimension::Builder::getFilterPipeline() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder Dimension::Builder::getFilterPipeline() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline -Dimension::Pipeline::getFilterPipeline() { - return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline( - _typeless.getPointerField(3)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline Dimension::Pipeline::getFilterPipeline() { + return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline(_typeless.getPointerField(3)); } #endif // !CAPNP_LITE -inline void Dimension::Builder::setFilterPipeline( - ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); +inline void Dimension::Builder::setFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder -Dimension::Builder::initFilterPipeline() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder Dimension::Builder::initFilterPipeline() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void Dimension::Builder::adoptFilterPipeline( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& - value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> -Dimension::Builder::disownFilterPipeline() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::FilterPipeline>:: - disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} - -inline ::tiledb::sm::serialization::capnp::Dimension::TileExtent::Which -Dimension::TileExtent::Reader::which() const { - return _reader.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); -} -inline ::tiledb::sm::serialization::capnp::Dimension::TileExtent::Which -Dimension::TileExtent::Builder::which() { + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> Dimension::Builder::disownFilterPipeline() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline ::tiledb::sm::serialization::capnp::Dimension::TileExtent::Which Dimension::TileExtent::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline ::tiledb::sm::serialization::capnp::Dimension::TileExtent::Which Dimension::TileExtent::Builder::which() { return _builder.getDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } @@ -20208,25 +15392,23 @@ inline bool Dimension::TileExtent::Reader::isInt8() const { inline bool Dimension::TileExtent::Builder::isInt8() { return which() == Dimension::TileExtent::INT8; } -inline ::int8_t Dimension::TileExtent::Reader::getInt8() const { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::INT8), - "Must check which() before get()ing a union member."); - return _reader.getDataField<::int8_t>( +inline ::int8_t Dimension::TileExtent::Reader::getInt8() const { + KJ_IREQUIRE((which() == Dimension::TileExtent::INT8), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int8_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::int8_t Dimension::TileExtent::Builder::getInt8() { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::INT8), - "Must check which() before get()ing a union member."); - return _builder.getDataField<::int8_t>( +inline ::int8_t Dimension::TileExtent::Builder::getInt8() { + KJ_IREQUIRE((which() == Dimension::TileExtent::INT8), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int8_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Dimension::TileExtent::Builder::setInt8(::int8_t value) { +inline void Dimension::TileExtent::Builder::setInt8( ::int8_t value) { _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::INT8); - _builder.setDataField<::int8_t>( + _builder.setDataField< ::int8_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -20236,25 +15418,23 @@ inline bool Dimension::TileExtent::Reader::isUint8() const { inline bool Dimension::TileExtent::Builder::isUint8() { return which() == Dimension::TileExtent::UINT8; } -inline ::uint8_t Dimension::TileExtent::Reader::getUint8() const { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::UINT8), - "Must check which() before get()ing a union member."); - return _reader.getDataField<::uint8_t>( +inline ::uint8_t Dimension::TileExtent::Reader::getUint8() const { + KJ_IREQUIRE((which() == Dimension::TileExtent::UINT8), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint8_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint8_t Dimension::TileExtent::Builder::getUint8() { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::UINT8), - "Must check which() before get()ing a union member."); - return _builder.getDataField<::uint8_t>( +inline ::uint8_t Dimension::TileExtent::Builder::getUint8() { + KJ_IREQUIRE((which() == Dimension::TileExtent::UINT8), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint8_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Dimension::TileExtent::Builder::setUint8(::uint8_t value) { +inline void Dimension::TileExtent::Builder::setUint8( ::uint8_t value) { _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::UINT8); - _builder.setDataField<::uint8_t>( + _builder.setDataField< ::uint8_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -20264,25 +15444,23 @@ inline bool Dimension::TileExtent::Reader::isInt16() const { inline bool Dimension::TileExtent::Builder::isInt16() { return which() == Dimension::TileExtent::INT16; } -inline ::int16_t Dimension::TileExtent::Reader::getInt16() const { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::INT16), - "Must check which() before get()ing a union member."); - return _reader.getDataField<::int16_t>( +inline ::int16_t Dimension::TileExtent::Reader::getInt16() const { + KJ_IREQUIRE((which() == Dimension::TileExtent::INT16), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int16_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::int16_t Dimension::TileExtent::Builder::getInt16() { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::INT16), - "Must check which() before get()ing a union member."); - return _builder.getDataField<::int16_t>( +inline ::int16_t Dimension::TileExtent::Builder::getInt16() { + KJ_IREQUIRE((which() == Dimension::TileExtent::INT16), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int16_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void Dimension::TileExtent::Builder::setInt16(::int16_t value) { +inline void Dimension::TileExtent::Builder::setInt16( ::int16_t value) { _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::INT16); - _builder.setDataField<::int16_t>( + _builder.setDataField< ::int16_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } @@ -20292,25 +15470,23 @@ inline bool Dimension::TileExtent::Reader::isUint16() const { inline bool Dimension::TileExtent::Builder::isUint16() { return which() == Dimension::TileExtent::UINT16; } -inline ::uint16_t Dimension::TileExtent::Reader::getUint16() const { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::UINT16), - "Must check which() before get()ing a union member."); - return _reader.getDataField<::uint16_t>( +inline ::uint16_t Dimension::TileExtent::Reader::getUint16() const { + KJ_IREQUIRE((which() == Dimension::TileExtent::UINT16), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint16_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint16_t Dimension::TileExtent::Builder::getUint16() { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::UINT16), - "Must check which() before get()ing a union member."); - return _builder.getDataField<::uint16_t>( +inline ::uint16_t Dimension::TileExtent::Builder::getUint16() { + KJ_IREQUIRE((which() == Dimension::TileExtent::UINT16), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint16_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void Dimension::TileExtent::Builder::setUint16(::uint16_t value) { +inline void Dimension::TileExtent::Builder::setUint16( ::uint16_t value) { _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::UINT16); - _builder.setDataField<::uint16_t>( + _builder.setDataField< ::uint16_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } @@ -20320,25 +15496,23 @@ inline bool Dimension::TileExtent::Reader::isInt32() const { inline bool Dimension::TileExtent::Builder::isInt32() { return which() == Dimension::TileExtent::INT32; } -inline ::int32_t Dimension::TileExtent::Reader::getInt32() const { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::INT32), - "Must check which() before get()ing a union member."); - return _reader.getDataField<::int32_t>( +inline ::int32_t Dimension::TileExtent::Reader::getInt32() const { + KJ_IREQUIRE((which() == Dimension::TileExtent::INT32), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::int32_t Dimension::TileExtent::Builder::getInt32() { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::INT32), - "Must check which() before get()ing a union member."); - return _builder.getDataField<::int32_t>( +inline ::int32_t Dimension::TileExtent::Builder::getInt32() { + KJ_IREQUIRE((which() == Dimension::TileExtent::INT32), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Dimension::TileExtent::Builder::setInt32(::int32_t value) { +inline void Dimension::TileExtent::Builder::setInt32( ::int32_t value) { _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::INT32); - _builder.setDataField<::int32_t>( + _builder.setDataField< ::int32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -20348,25 +15522,23 @@ inline bool Dimension::TileExtent::Reader::isUint32() const { inline bool Dimension::TileExtent::Builder::isUint32() { return which() == Dimension::TileExtent::UINT32; } -inline ::uint32_t Dimension::TileExtent::Reader::getUint32() const { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::UINT32), - "Must check which() before get()ing a union member."); - return _reader.getDataField<::uint32_t>( +inline ::uint32_t Dimension::TileExtent::Reader::getUint32() const { + KJ_IREQUIRE((which() == Dimension::TileExtent::UINT32), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint32_t Dimension::TileExtent::Builder::getUint32() { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::UINT32), - "Must check which() before get()ing a union member."); - return _builder.getDataField<::uint32_t>( +inline ::uint32_t Dimension::TileExtent::Builder::getUint32() { + KJ_IREQUIRE((which() == Dimension::TileExtent::UINT32), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Dimension::TileExtent::Builder::setUint32(::uint32_t value) { +inline void Dimension::TileExtent::Builder::setUint32( ::uint32_t value) { _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::UINT32); - _builder.setDataField<::uint32_t>( + _builder.setDataField< ::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -20376,25 +15548,23 @@ inline bool Dimension::TileExtent::Reader::isInt64() const { inline bool Dimension::TileExtent::Builder::isInt64() { return which() == Dimension::TileExtent::INT64; } -inline ::int64_t Dimension::TileExtent::Reader::getInt64() const { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::INT64), - "Must check which() before get()ing a union member."); - return _reader.getDataField<::int64_t>( +inline ::int64_t Dimension::TileExtent::Reader::getInt64() const { + KJ_IREQUIRE((which() == Dimension::TileExtent::INT64), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::int64_t Dimension::TileExtent::Builder::getInt64() { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::INT64), - "Must check which() before get()ing a union member."); - return _builder.getDataField<::int64_t>( +inline ::int64_t Dimension::TileExtent::Builder::getInt64() { + KJ_IREQUIRE((which() == Dimension::TileExtent::INT64), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Dimension::TileExtent::Builder::setInt64(::int64_t value) { +inline void Dimension::TileExtent::Builder::setInt64( ::int64_t value) { _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::INT64); - _builder.setDataField<::int64_t>( + _builder.setDataField< ::int64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -20404,25 +15574,23 @@ inline bool Dimension::TileExtent::Reader::isUint64() const { inline bool Dimension::TileExtent::Builder::isUint64() { return which() == Dimension::TileExtent::UINT64; } -inline ::uint64_t Dimension::TileExtent::Reader::getUint64() const { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::UINT64), - "Must check which() before get()ing a union member."); - return _reader.getDataField<::uint64_t>( +inline ::uint64_t Dimension::TileExtent::Reader::getUint64() const { + KJ_IREQUIRE((which() == Dimension::TileExtent::UINT64), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t Dimension::TileExtent::Builder::getUint64() { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::UINT64), - "Must check which() before get()ing a union member."); - return _builder.getDataField<::uint64_t>( +inline ::uint64_t Dimension::TileExtent::Builder::getUint64() { + KJ_IREQUIRE((which() == Dimension::TileExtent::UINT64), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Dimension::TileExtent::Builder::setUint64(::uint64_t value) { +inline void Dimension::TileExtent::Builder::setUint64( ::uint64_t value) { _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::UINT64); - _builder.setDataField<::uint64_t>( + _builder.setDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -20433,23 +15601,21 @@ inline bool Dimension::TileExtent::Builder::isFloat32() { return which() == Dimension::TileExtent::FLOAT32; } inline float Dimension::TileExtent::Reader::getFloat32() const { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::FLOAT32), - "Must check which() before get()ing a union member."); - return _reader.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); + KJ_IREQUIRE((which() == Dimension::TileExtent::FLOAT32), + "Must check which() before get()ing a union member."); + return _reader.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline float Dimension::TileExtent::Builder::getFloat32() { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::FLOAT32), - "Must check which() before get()ing a union member."); + KJ_IREQUIRE((which() == Dimension::TileExtent::FLOAT32), + "Must check which() before get()ing a union member."); return _builder.getDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline void Dimension::TileExtent::Builder::setFloat32(float value) { _builder.setDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS, - Dimension::TileExtent::FLOAT32); + ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::FLOAT32); _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -20461,263 +15627,207 @@ inline bool Dimension::TileExtent::Builder::isFloat64() { return which() == Dimension::TileExtent::FLOAT64; } inline double Dimension::TileExtent::Reader::getFloat64() const { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::FLOAT64), - "Must check which() before get()ing a union member."); + KJ_IREQUIRE((which() == Dimension::TileExtent::FLOAT64), + "Must check which() before get()ing a union member."); return _reader.getDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline double Dimension::TileExtent::Builder::getFloat64() { - KJ_IREQUIRE( - (which() == Dimension::TileExtent::FLOAT64), - "Must check which() before get()ing a union member."); + KJ_IREQUIRE((which() == Dimension::TileExtent::FLOAT64), + "Must check which() before get()ing a union member."); return _builder.getDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline void Dimension::TileExtent::Builder::setFloat64(double value) { _builder.setDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS, - Dimension::TileExtent::FLOAT64); + ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::FLOAT64); _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool Domain::Reader::hasCellOrder() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool Domain::Builder::hasCellOrder() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Domain::Reader::getCellOrder() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Domain::Reader::getCellOrder() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Domain::Builder::getCellOrder() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Domain::Builder::getCellOrder() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Domain::Builder::setCellOrder(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void Domain::Builder::setCellOrder( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Domain::Builder::initCellOrder( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Domain::Builder::initCellOrder(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void Domain::Builder::adoptCellOrder( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Domain::Builder::disownCellOrder() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Domain::Builder::disownCellOrder() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Domain::Reader::hasDimensions() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool Domain::Builder::hasDimensions() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>::Reader -Domain::Reader::getDimensions() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>::Builder -Domain::Builder::getDimensions() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline void Domain::Builder::setDimensions( - ::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>::Builder -Domain::Builder::initDimensions(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>::Reader Domain::Reader::getDimensions() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>::Builder Domain::Builder::getDimensions() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void Domain::Builder::setDimensions( ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>::Builder Domain::Builder::initDimensions(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void Domain::Builder::adoptDimensions( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>> -Domain::Builder::disownDimensions() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Dimension, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>> Domain::Builder::disownDimensions() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Domain::Reader::hasTileOrder() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool Domain::Builder::hasTileOrder() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Domain::Reader::getTileOrder() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Domain::Reader::getTileOrder() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Domain::Builder::getTileOrder() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Domain::Builder::getTileOrder() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void Domain::Builder::setTileOrder(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void Domain::Builder::setTileOrder( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Domain::Builder::initTileOrder( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Domain::Builder::initTileOrder(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void Domain::Builder::adoptTileOrder( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Domain::Builder::disownTileOrder() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Domain::Builder::disownTileOrder() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Domain::Reader::hasType() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool Domain::Builder::hasType() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Domain::Reader::getType() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Domain::Reader::getType() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Domain::Builder::getType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Domain::Builder::getType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline void Domain::Builder::setType(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); +inline void Domain::Builder::setType( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Domain::Builder::initType(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Domain::Builder::initType(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); } -inline void Domain::Builder::adoptType(::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); +inline void Domain::Builder::adoptType( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Domain::Builder::disownType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Domain::Builder::disownType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::int64_t Error::Reader::getCode() const { - return _reader.getDataField<::int64_t>( +inline ::int64_t Error::Reader::getCode() const { + return _reader.getDataField< ::int64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::int64_t Error::Builder::getCode() { - return _builder.getDataField<::int64_t>( +inline ::int64_t Error::Builder::getCode() { + return _builder.getDataField< ::int64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void Error::Builder::setCode(::int64_t value) { - _builder.setDataField<::int64_t>( +inline void Error::Builder::setCode( ::int64_t value) { + _builder.setDataField< ::int64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool Error::Reader::hasMessage() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool Error::Builder::hasMessage() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Error::Reader::getMessage() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Error::Reader::getMessage() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Error::Builder::getMessage() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Error::Builder::getMessage() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Error::Builder::setMessage(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void Error::Builder::setMessage( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Error::Builder::initMessage(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Error::Builder::initMessage(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void Error::Builder::adoptMessage( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Error::Builder::disownMessage() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Error::Builder::disownMessage() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline double FloatScaleConfig::Reader::getScale() const { @@ -20748,22 +15858,23 @@ inline void FloatScaleConfig::Builder::setOffset(double value) { ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t FloatScaleConfig::Reader::getByteWidth() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t FloatScaleConfig::Reader::getByteWidth() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t FloatScaleConfig::Builder::getByteWidth() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t FloatScaleConfig::Builder::getByteWidth() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void FloatScaleConfig::Builder::setByteWidth(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void FloatScaleConfig::Builder::setByteWidth( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline float WebpConfig::Reader::getQuality() const { - return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline float WebpConfig::Builder::getQuality() { @@ -20775,22 +15886,23 @@ inline void WebpConfig::Builder::setQuality(float value) { ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint8_t WebpConfig::Reader::getFormat() const { - return _reader.getDataField<::uint8_t>( +inline ::uint8_t WebpConfig::Reader::getFormat() const { + return _reader.getDataField< ::uint8_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS); } -inline ::uint8_t WebpConfig::Builder::getFormat() { - return _builder.getDataField<::uint8_t>( +inline ::uint8_t WebpConfig::Builder::getFormat() { + return _builder.getDataField< ::uint8_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS); } -inline void WebpConfig::Builder::setFormat(::uint8_t value) { - _builder.setDataField<::uint8_t>( +inline void WebpConfig::Builder::setFormat( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS, value); } inline bool WebpConfig::Reader::getLossless() const { - return _reader.getDataField(::capnp::bounded<40>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<40>() * ::capnp::ELEMENTS); } inline bool WebpConfig::Builder::getLossless() { @@ -20802,68 +15914,66 @@ inline void WebpConfig::Builder::setLossless(bool value) { ::capnp::bounded<40>() * ::capnp::ELEMENTS, value); } -inline ::uint16_t WebpConfig::Reader::getExtentX() const { - return _reader.getDataField<::uint16_t>( +inline ::uint16_t WebpConfig::Reader::getExtentX() const { + return _reader.getDataField< ::uint16_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS); } -inline ::uint16_t WebpConfig::Builder::getExtentX() { - return _builder.getDataField<::uint16_t>( +inline ::uint16_t WebpConfig::Builder::getExtentX() { + return _builder.getDataField< ::uint16_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS); } -inline void WebpConfig::Builder::setExtentX(::uint16_t value) { - _builder.setDataField<::uint16_t>( +inline void WebpConfig::Builder::setExtentX( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS, value); } -inline ::uint16_t WebpConfig::Reader::getExtentY() const { - return _reader.getDataField<::uint16_t>( +inline ::uint16_t WebpConfig::Reader::getExtentY() const { + return _reader.getDataField< ::uint16_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS); } -inline ::uint16_t WebpConfig::Builder::getExtentY() { - return _builder.getDataField<::uint16_t>( +inline ::uint16_t WebpConfig::Builder::getExtentY() { + return _builder.getDataField< ::uint16_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS); } -inline void WebpConfig::Builder::setExtentY(::uint16_t value) { - _builder.setDataField<::uint16_t>( +inline void WebpConfig::Builder::setExtentY( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS, value); } inline bool Filter::Reader::hasType() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool Filter::Builder::hasType() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Filter::Reader::getType() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Filter::Reader::getType() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Filter::Builder::getType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Filter::Builder::getType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Filter::Builder::setType(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void Filter::Builder::setType( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Filter::Builder::initType(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Filter::Builder::initType(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } -inline void Filter::Builder::adoptType(::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); +inline void Filter::Builder::adoptType( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Filter::Builder::disownType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Filter::Builder::disownType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline typename Filter::Data::Reader Filter::Reader::getData() const { @@ -20878,133 +15988,96 @@ inline typename Filter::Data::Pipeline Filter::Pipeline::getData() { } #endif // !CAPNP_LITE inline typename Filter::Data::Builder Filter::Builder::initData() { - _builder.setDataField<::uint16_t>( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, 0); - _builder.setDataField<::uint16_t>( - ::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); - _builder.setDataField<::uint32_t>( - ::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); - _builder.setDataField<::uint64_t>( - ::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(::capnp::bounded<0>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint32_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS).clear(); return typename Filter::Data::Builder(_builder); } inline bool Filter::Reader::hasFloatScaleConfig() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool Filter::Builder::hasFloatScaleConfig() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Reader -Filter::Reader::getFloatScaleConfig() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FloatScaleConfig>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Reader Filter::Reader::getFloatScaleConfig() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FloatScaleConfig>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Builder -Filter::Builder::getFloatScaleConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FloatScaleConfig>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Builder Filter::Builder::getFloatScaleConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FloatScaleConfig>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Pipeline -Filter::Pipeline::getFloatScaleConfig() { - return ::tiledb::sm::serialization::capnp::FloatScaleConfig::Pipeline( - _typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Pipeline Filter::Pipeline::getFloatScaleConfig() { + return ::tiledb::sm::serialization::capnp::FloatScaleConfig::Pipeline(_typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void Filter::Builder::setFloatScaleConfig( - ::tiledb::sm::serialization::capnp::FloatScaleConfig::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FloatScaleConfig>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void Filter::Builder::setFloatScaleConfig( ::tiledb::sm::serialization::capnp::FloatScaleConfig::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FloatScaleConfig>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Builder -Filter::Builder::initFloatScaleConfig() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::FloatScaleConfig>:: - init(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Builder Filter::Builder::initFloatScaleConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FloatScaleConfig>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void Filter::Builder::adoptFloatScaleConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FloatScaleConfig>&& - value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::FloatScaleConfig>:: - adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FloatScaleConfig> -Filter::Builder::disownFloatScaleConfig() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::FloatScaleConfig>:: - disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FloatScaleConfig>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FloatScaleConfig>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FloatScaleConfig> Filter::Builder::disownFloatScaleConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FloatScaleConfig>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Filter::Reader::hasWebpConfig() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool Filter::Builder::hasWebpConfig() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::WebpConfig::Reader -Filter::Reader::getWebpConfig() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::WebpConfig>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::WebpConfig::Reader Filter::Reader::getWebpConfig() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::WebpConfig>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::WebpConfig::Builder -Filter::Builder::getWebpConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::WebpConfig>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::WebpConfig::Builder Filter::Builder::getWebpConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::WebpConfig>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::WebpConfig::Pipeline -Filter::Pipeline::getWebpConfig() { - return ::tiledb::sm::serialization::capnp::WebpConfig::Pipeline( - _typeless.getPointerField(3)); +inline ::tiledb::sm::serialization::capnp::WebpConfig::Pipeline Filter::Pipeline::getWebpConfig() { + return ::tiledb::sm::serialization::capnp::WebpConfig::Pipeline(_typeless.getPointerField(3)); } #endif // !CAPNP_LITE -inline void Filter::Builder::setWebpConfig( - ::tiledb::sm::serialization::capnp::WebpConfig::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::WebpConfig>:: - set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); +inline void Filter::Builder::setWebpConfig( ::tiledb::sm::serialization::capnp::WebpConfig::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::WebpConfig>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::WebpConfig::Builder -Filter::Builder::initWebpConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::WebpConfig>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::WebpConfig::Builder Filter::Builder::initWebpConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::WebpConfig>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void Filter::Builder::adoptWebpConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::WebpConfig>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::WebpConfig>:: - adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::WebpConfig>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::WebpConfig>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::WebpConfig> -Filter::Builder::disownWebpConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::WebpConfig>::disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::WebpConfig> Filter::Builder::disownWebpConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::WebpConfig>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Filter::Data::Which -Filter::Data::Reader::which() const { - return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); +inline ::tiledb::sm::serialization::capnp::Filter::Data::Which Filter::Data::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::tiledb::sm::serialization::capnp::Filter::Data::Which -Filter::Data::Builder::which() { +inline ::tiledb::sm::serialization::capnp::Filter::Data::Which Filter::Data::Builder::which() { return _builder.getDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } @@ -21016,60 +16089,51 @@ inline bool Filter::Data::Builder::isText() { return which() == Filter::Data::TEXT; } inline bool Filter::Data::Reader::hasText() const { - if (which() != Filter::Data::TEXT) - return false; - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + if (which() != Filter::Data::TEXT) return false; + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool Filter::Data::Builder::hasText() { - if (which() != Filter::Data::TEXT) - return false; - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::Text::Reader Filter::Data::Reader::getText() const { - KJ_IREQUIRE( - (which() == Filter::Data::TEXT), - "Must check which() before get()ing a union member."); - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder Filter::Data::Builder::getText() { - KJ_IREQUIRE( - (which() == Filter::Data::TEXT), - "Must check which() before get()ing a union member."); - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void Filter::Data::Builder::setText(::capnp::Text::Reader value) { + if (which() != Filter::Data::TEXT) return false; + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader Filter::Data::Reader::getText() const { + KJ_IREQUIRE((which() == Filter::Data::TEXT), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder Filter::Data::Builder::getText() { + KJ_IREQUIRE((which() == Filter::Data::TEXT), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void Filter::Data::Builder::setText( ::capnp::Text::Reader value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::TEXT); - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Filter::Data::Builder::initText( - unsigned int size) { +inline ::capnp::Text::Builder Filter::Data::Builder::initText(unsigned int size) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::TEXT); - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void Filter::Data::Builder::adoptText( - ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::Orphan< ::capnp::Text>&& value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::TEXT); - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Filter::Data::Builder::disownText() { - KJ_IREQUIRE( - (which() == Filter::Data::TEXT), - "Must check which() before get()ing a union member."); - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Filter::Data::Builder::disownText() { + KJ_IREQUIRE((which() == Filter::Data::TEXT), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Filter::Data::Reader::isBytes() const { @@ -21079,60 +16143,51 @@ inline bool Filter::Data::Builder::isBytes() { return which() == Filter::Data::BYTES; } inline bool Filter::Data::Reader::hasBytes() const { - if (which() != Filter::Data::BYTES) - return false; - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + if (which() != Filter::Data::BYTES) return false; + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool Filter::Data::Builder::hasBytes() { - if (which() != Filter::Data::BYTES) - return false; - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::Data::Reader Filter::Data::Reader::getBytes() const { - KJ_IREQUIRE( - (which() == Filter::Data::BYTES), - "Must check which() before get()ing a union member."); - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::Data::Builder Filter::Data::Builder::getBytes() { - KJ_IREQUIRE( - (which() == Filter::Data::BYTES), - "Must check which() before get()ing a union member."); - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void Filter::Data::Builder::setBytes(::capnp::Data::Reader value) { + if (which() != Filter::Data::BYTES) return false; + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Data::Reader Filter::Data::Reader::getBytes() const { + KJ_IREQUIRE((which() == Filter::Data::BYTES), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Data::Builder Filter::Data::Builder::getBytes() { + KJ_IREQUIRE((which() == Filter::Data::BYTES), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void Filter::Data::Builder::setBytes( ::capnp::Data::Reader value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::BYTES); - ::capnp::_::PointerHelpers<::capnp::Data>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); + ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::capnp::Data::Builder Filter::Data::Builder::initBytes( - unsigned int size) { +inline ::capnp::Data::Builder Filter::Data::Builder::initBytes(unsigned int size) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::BYTES); - return ::capnp::_::PointerHelpers<::capnp::Data>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void Filter::Data::Builder::adoptBytes( - ::capnp::Orphan<::capnp::Data>&& value) { + ::capnp::Orphan< ::capnp::Data>&& value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::BYTES); - ::capnp::_::PointerHelpers<::capnp::Data>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Data> Filter::Data::Builder::disownBytes() { - KJ_IREQUIRE( - (which() == Filter::Data::BYTES), - "Must check which() before get()ing a union member."); - return ::capnp::_::PointerHelpers<::capnp::Data>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Data> Filter::Data::Builder::disownBytes() { + KJ_IREQUIRE((which() == Filter::Data::BYTES), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Filter::Data::Reader::isInt8() const { @@ -21141,25 +16196,23 @@ inline bool Filter::Data::Reader::isInt8() const { inline bool Filter::Data::Builder::isInt8() { return which() == Filter::Data::INT8; } -inline ::int8_t Filter::Data::Reader::getInt8() const { - KJ_IREQUIRE( - (which() == Filter::Data::INT8), - "Must check which() before get()ing a union member."); - return _reader.getDataField<::int8_t>( +inline ::int8_t Filter::Data::Reader::getInt8() const { + KJ_IREQUIRE((which() == Filter::Data::INT8), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int8_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::int8_t Filter::Data::Builder::getInt8() { - KJ_IREQUIRE( - (which() == Filter::Data::INT8), - "Must check which() before get()ing a union member."); - return _builder.getDataField<::int8_t>( +inline ::int8_t Filter::Data::Builder::getInt8() { + KJ_IREQUIRE((which() == Filter::Data::INT8), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int8_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void Filter::Data::Builder::setInt8(::int8_t value) { +inline void Filter::Data::Builder::setInt8( ::int8_t value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::INT8); - _builder.setDataField<::int8_t>( + _builder.setDataField< ::int8_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } @@ -21169,25 +16222,23 @@ inline bool Filter::Data::Reader::isUint8() const { inline bool Filter::Data::Builder::isUint8() { return which() == Filter::Data::UINT8; } -inline ::uint8_t Filter::Data::Reader::getUint8() const { - KJ_IREQUIRE( - (which() == Filter::Data::UINT8), - "Must check which() before get()ing a union member."); - return _reader.getDataField<::uint8_t>( +inline ::uint8_t Filter::Data::Reader::getUint8() const { + KJ_IREQUIRE((which() == Filter::Data::UINT8), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint8_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint8_t Filter::Data::Builder::getUint8() { - KJ_IREQUIRE( - (which() == Filter::Data::UINT8), - "Must check which() before get()ing a union member."); - return _builder.getDataField<::uint8_t>( +inline ::uint8_t Filter::Data::Builder::getUint8() { + KJ_IREQUIRE((which() == Filter::Data::UINT8), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint8_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void Filter::Data::Builder::setUint8(::uint8_t value) { +inline void Filter::Data::Builder::setUint8( ::uint8_t value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::UINT8); - _builder.setDataField<::uint8_t>( + _builder.setDataField< ::uint8_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } @@ -21197,25 +16248,23 @@ inline bool Filter::Data::Reader::isInt16() const { inline bool Filter::Data::Builder::isInt16() { return which() == Filter::Data::INT16; } -inline ::int16_t Filter::Data::Reader::getInt16() const { - KJ_IREQUIRE( - (which() == Filter::Data::INT16), - "Must check which() before get()ing a union member."); - return _reader.getDataField<::int16_t>( +inline ::int16_t Filter::Data::Reader::getInt16() const { + KJ_IREQUIRE((which() == Filter::Data::INT16), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int16_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::int16_t Filter::Data::Builder::getInt16() { - KJ_IREQUIRE( - (which() == Filter::Data::INT16), - "Must check which() before get()ing a union member."); - return _builder.getDataField<::int16_t>( +inline ::int16_t Filter::Data::Builder::getInt16() { + KJ_IREQUIRE((which() == Filter::Data::INT16), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int16_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Filter::Data::Builder::setInt16(::int16_t value) { +inline void Filter::Data::Builder::setInt16( ::int16_t value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::INT16); - _builder.setDataField<::int16_t>( + _builder.setDataField< ::int16_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -21225,25 +16274,23 @@ inline bool Filter::Data::Reader::isUint16() const { inline bool Filter::Data::Builder::isUint16() { return which() == Filter::Data::UINT16; } -inline ::uint16_t Filter::Data::Reader::getUint16() const { - KJ_IREQUIRE( - (which() == Filter::Data::UINT16), - "Must check which() before get()ing a union member."); - return _reader.getDataField<::uint16_t>( +inline ::uint16_t Filter::Data::Reader::getUint16() const { + KJ_IREQUIRE((which() == Filter::Data::UINT16), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint16_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint16_t Filter::Data::Builder::getUint16() { - KJ_IREQUIRE( - (which() == Filter::Data::UINT16), - "Must check which() before get()ing a union member."); - return _builder.getDataField<::uint16_t>( +inline ::uint16_t Filter::Data::Builder::getUint16() { + KJ_IREQUIRE((which() == Filter::Data::UINT16), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint16_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Filter::Data::Builder::setUint16(::uint16_t value) { +inline void Filter::Data::Builder::setUint16( ::uint16_t value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::UINT16); - _builder.setDataField<::uint16_t>( + _builder.setDataField< ::uint16_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -21253,25 +16300,23 @@ inline bool Filter::Data::Reader::isInt32() const { inline bool Filter::Data::Builder::isInt32() { return which() == Filter::Data::INT32; } -inline ::int32_t Filter::Data::Reader::getInt32() const { - KJ_IREQUIRE( - (which() == Filter::Data::INT32), - "Must check which() before get()ing a union member."); - return _reader.getDataField<::int32_t>( +inline ::int32_t Filter::Data::Reader::getInt32() const { + KJ_IREQUIRE((which() == Filter::Data::INT32), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::int32_t Filter::Data::Builder::getInt32() { - KJ_IREQUIRE( - (which() == Filter::Data::INT32), - "Must check which() before get()ing a union member."); - return _builder.getDataField<::int32_t>( +inline ::int32_t Filter::Data::Builder::getInt32() { + KJ_IREQUIRE((which() == Filter::Data::INT32), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Filter::Data::Builder::setInt32(::int32_t value) { +inline void Filter::Data::Builder::setInt32( ::int32_t value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::INT32); - _builder.setDataField<::int32_t>( + _builder.setDataField< ::int32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -21281,25 +16326,23 @@ inline bool Filter::Data::Reader::isUint32() const { inline bool Filter::Data::Builder::isUint32() { return which() == Filter::Data::UINT32; } -inline ::uint32_t Filter::Data::Reader::getUint32() const { - KJ_IREQUIRE( - (which() == Filter::Data::UINT32), - "Must check which() before get()ing a union member."); - return _reader.getDataField<::uint32_t>( +inline ::uint32_t Filter::Data::Reader::getUint32() const { + KJ_IREQUIRE((which() == Filter::Data::UINT32), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint32_t Filter::Data::Builder::getUint32() { - KJ_IREQUIRE( - (which() == Filter::Data::UINT32), - "Must check which() before get()ing a union member."); - return _builder.getDataField<::uint32_t>( +inline ::uint32_t Filter::Data::Builder::getUint32() { + KJ_IREQUIRE((which() == Filter::Data::UINT32), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Filter::Data::Builder::setUint32(::uint32_t value) { +inline void Filter::Data::Builder::setUint32( ::uint32_t value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::UINT32); - _builder.setDataField<::uint32_t>( + _builder.setDataField< ::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -21309,25 +16352,23 @@ inline bool Filter::Data::Reader::isInt64() const { inline bool Filter::Data::Builder::isInt64() { return which() == Filter::Data::INT64; } -inline ::int64_t Filter::Data::Reader::getInt64() const { - KJ_IREQUIRE( - (which() == Filter::Data::INT64), - "Must check which() before get()ing a union member."); - return _reader.getDataField<::int64_t>( +inline ::int64_t Filter::Data::Reader::getInt64() const { + KJ_IREQUIRE((which() == Filter::Data::INT64), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::int64_t Filter::Data::Builder::getInt64() { - KJ_IREQUIRE( - (which() == Filter::Data::INT64), - "Must check which() before get()ing a union member."); - return _builder.getDataField<::int64_t>( +inline ::int64_t Filter::Data::Builder::getInt64() { + KJ_IREQUIRE((which() == Filter::Data::INT64), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Filter::Data::Builder::setInt64(::int64_t value) { +inline void Filter::Data::Builder::setInt64( ::int64_t value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::INT64); - _builder.setDataField<::int64_t>( + _builder.setDataField< ::int64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -21337,25 +16378,23 @@ inline bool Filter::Data::Reader::isUint64() const { inline bool Filter::Data::Builder::isUint64() { return which() == Filter::Data::UINT64; } -inline ::uint64_t Filter::Data::Reader::getUint64() const { - KJ_IREQUIRE( - (which() == Filter::Data::UINT64), - "Must check which() before get()ing a union member."); - return _reader.getDataField<::uint64_t>( +inline ::uint64_t Filter::Data::Reader::getUint64() const { + KJ_IREQUIRE((which() == Filter::Data::UINT64), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t Filter::Data::Builder::getUint64() { - KJ_IREQUIRE( - (which() == Filter::Data::UINT64), - "Must check which() before get()ing a union member."); - return _builder.getDataField<::uint64_t>( +inline ::uint64_t Filter::Data::Builder::getUint64() { + KJ_IREQUIRE((which() == Filter::Data::UINT64), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Filter::Data::Builder::setUint64(::uint64_t value) { +inline void Filter::Data::Builder::setUint64( ::uint64_t value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::UINT64); - _builder.setDataField<::uint64_t>( + _builder.setDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -21366,16 +16405,15 @@ inline bool Filter::Data::Builder::isFloat32() { return which() == Filter::Data::FLOAT32; } inline float Filter::Data::Reader::getFloat32() const { - KJ_IREQUIRE( - (which() == Filter::Data::FLOAT32), - "Must check which() before get()ing a union member."); - return _reader.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); + KJ_IREQUIRE((which() == Filter::Data::FLOAT32), + "Must check which() before get()ing a union member."); + return _reader.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline float Filter::Data::Builder::getFloat32() { - KJ_IREQUIRE( - (which() == Filter::Data::FLOAT32), - "Must check which() before get()ing a union member."); + KJ_IREQUIRE((which() == Filter::Data::FLOAT32), + "Must check which() before get()ing a union member."); return _builder.getDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } @@ -21393,17 +16431,15 @@ inline bool Filter::Data::Builder::isFloat64() { return which() == Filter::Data::FLOAT64; } inline double Filter::Data::Reader::getFloat64() const { - KJ_IREQUIRE( - (which() == Filter::Data::FLOAT64), - "Must check which() before get()ing a union member."); + KJ_IREQUIRE((which() == Filter::Data::FLOAT64), + "Must check which() before get()ing a union member."); return _reader.getDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline double Filter::Data::Builder::getFloat64() { - KJ_IREQUIRE( - (which() == Filter::Data::FLOAT64), - "Must check which() before get()ing a union member."); + KJ_IREQUIRE((which() == Filter::Data::FLOAT64), + "Must check which() before get()ing a union member."); return _builder.getDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } @@ -21415,277 +16451,185 @@ inline void Filter::Data::Builder::setFloat64(double value) { } inline bool FilterPipeline::Reader::hasFilters() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool FilterPipeline::Builder::hasFilters() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>::Reader -FilterPipeline::Reader::getFilters() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>::Builder -FilterPipeline::Builder::getFilters() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void FilterPipeline::Builder::setFilters( - ::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>::Builder -FilterPipeline::Builder::initFilters(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>::Reader FilterPipeline::Reader::getFilters() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>::Builder FilterPipeline::Builder::getFilters() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void FilterPipeline::Builder::setFilters( ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>::Builder FilterPipeline::Builder::initFilters(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void FilterPipeline::Builder::adoptFilters( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>> -FilterPipeline::Builder::disownFilters() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Filter, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>> FilterPipeline::Builder::disownFilters() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } template inline bool Map::Reader::hasEntries() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } template inline bool Map::Builder::hasEntries() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } template -inline typename ::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>::Reader -Map::Reader::getEntries() const { - return ::capnp::_::PointerHelpers<::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); +inline typename ::capnp::List::Entry, ::capnp::Kind::STRUCT>::Reader Map::Reader::getEntries() const { + return ::capnp::_::PointerHelpers< ::capnp::List::Entry, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } template -inline typename ::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>::Builder -Map::Builder::getEntries() { - return ::capnp::_::PointerHelpers<::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); +inline typename ::capnp::List::Entry, ::capnp::Kind::STRUCT>::Builder Map::Builder::getEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List::Entry, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } template -inline void Map::Builder::setEntries( - typename ::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void Map::Builder::setEntries(typename ::capnp::List::Entry, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List::Entry, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } template -inline typename ::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>::Builder -Map::Builder::initEntries(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline typename ::capnp::List::Entry, ::capnp::Kind::STRUCT>::Builder Map::Builder::initEntries(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List::Entry, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } template inline void Map::Builder::adoptEntries( - ::capnp::Orphan<::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List::Entry, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List::Entry, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } template -inline ::capnp::Orphan<::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>> -Map::Builder::disownEntries() { - return ::capnp::_::PointerHelpers<::capnp::List< - typename ::tiledb::sm::serialization::capnp::Map::Entry, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List::Entry, ::capnp::Kind::STRUCT>> Map::Builder::disownEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List::Entry, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } template inline bool Map::Entry::Reader::hasKey() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } template inline bool Map::Entry::Builder::hasKey() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } template -inline ::capnp::ReaderFor Map::Entry::Reader::getKey() const { - return ::capnp::_::PointerHelpers::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::ReaderFor Map::Entry::Reader::getKey() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } template -inline ::capnp::BuilderFor Map::Entry::Builder::getKey() { - return ::capnp::_::PointerHelpers::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::BuilderFor Map::Entry::Builder::getKey() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE template -inline ::capnp::PipelineFor Map::Entry::Pipeline::getKey() { - return ::capnp::PipelineFor(_typeless.getPointerField(0)); +inline ::capnp::PipelineFor Map::Entry::Pipeline::getKey() { + return ::capnp::PipelineFor(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE template -inline void Map::Entry::Builder::setKey( - ::capnp::ReaderFor value) { - ::capnp::_::PointerHelpers::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void Map::Entry::Builder::setKey( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } template -inline ::capnp::BuilderFor Map::Entry::Builder::initKey() { - return ::capnp::_::PointerHelpers::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::BuilderFor Map::Entry::Builder::initKey() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } template -inline ::capnp::BuilderFor Map::Entry::Builder::initKey( - unsigned int size) { - return ::capnp::_::PointerHelpers::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::BuilderFor Map::Entry::Builder::initKey(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } template inline void Map::Entry::Builder::adoptKey( ::capnp::Orphan&& value) { - ::capnp::_::PointerHelpers::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } template inline ::capnp::Orphan Map::Entry::Builder::disownKey() { - return ::capnp::_::PointerHelpers::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } template inline bool Map::Entry::Reader::hasValue() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } template inline bool Map::Entry::Builder::hasValue() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } template -inline ::capnp::ReaderFor Map::Entry::Reader::getValue() - const { - return ::capnp::_::PointerHelpers::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::ReaderFor Map::Entry::Reader::getValue() const { + return ::capnp::_::PointerHelpers::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } template -inline ::capnp::BuilderFor Map::Entry::Builder::getValue() { - return ::capnp::_::PointerHelpers::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::BuilderFor Map::Entry::Builder::getValue() { + return ::capnp::_::PointerHelpers::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE template -inline ::capnp::PipelineFor -Map::Entry::Pipeline::getValue() { - return ::capnp::PipelineFor(_typeless.getPointerField(1)); +inline ::capnp::PipelineFor Map::Entry::Pipeline::getValue() { + return ::capnp::PipelineFor(_typeless.getPointerField(1)); } #endif // !CAPNP_LITE template -inline void Map::Entry::Builder::setValue( - ::capnp::ReaderFor value) { - ::capnp::_::PointerHelpers::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void Map::Entry::Builder::setValue( ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } template -inline ::capnp::BuilderFor Map::Entry::Builder::initValue() { - return ::capnp::_::PointerHelpers::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::BuilderFor Map::Entry::Builder::initValue() { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } template -inline ::capnp::BuilderFor Map::Entry::Builder::initValue( - unsigned int size) { - return ::capnp::_::PointerHelpers::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); +inline ::capnp::BuilderFor Map::Entry::Builder::initValue(unsigned int size) { + return ::capnp::_::PointerHelpers::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } template inline void Map::Entry::Builder::adoptValue( ::capnp::Orphan&& value) { - ::capnp::_::PointerHelpers::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } template inline ::capnp::Orphan Map::Entry::Builder::disownValue() { - return ::capnp::_::PointerHelpers::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } // Map::Entry @@ -21700,29 +16644,22 @@ constexpr uint16_t Map::Entry::_capnpPrivate::pointerCount; template constexpr ::capnp::Kind Map::Entry::_capnpPrivate::kind; template -constexpr ::capnp::_::RawSchema const* - Map::Entry::_capnpPrivate::schema; +constexpr ::capnp::_::RawSchema const* Map::Entry::_capnpPrivate::schema; #endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL template -const ::capnp::_::RawBrandedSchema::Scope - Map::Entry::_capnpPrivate::brandScopes[] = { - {0xf179c194ae71718c, brandBindings + 0, 2, false}, +const ::capnp::_::RawBrandedSchema::Scope Map::Entry::_capnpPrivate::brandScopes[] = { + { 0xf179c194ae71718c, brandBindings + 0, 2, false}, }; template -const ::capnp::_::RawBrandedSchema::Binding - Map::Entry::_capnpPrivate::brandBindings[] = { - ::capnp::_::brandBindingFor(), - ::capnp::_::brandBindingFor(), +const ::capnp::_::RawBrandedSchema::Binding Map::Entry::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), }; template -const ::capnp::_::RawBrandedSchema - Map::Entry::_capnpPrivate::specificBrand = { - &::capnp::schemas::s_db5514c8aaf6faea, - brandScopes, - nullptr, - 1, - 0, - nullptr}; +const ::capnp::_::RawBrandedSchema Map::Entry::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_db5514c8aaf6faea, brandScopes, nullptr, + 1, 0, nullptr +}; #endif // !CAPNP_LITE // Map @@ -21740,710 +16677,439 @@ template constexpr ::capnp::_::RawSchema const* Map::_capnpPrivate::schema; #endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL template -const ::capnp::_::RawBrandedSchema::Scope - Map::_capnpPrivate::brandScopes[] = { - {0xf179c194ae71718c, brandBindings + 0, 2, false}, +const ::capnp::_::RawBrandedSchema::Scope Map::_capnpPrivate::brandScopes[] = { + { 0xf179c194ae71718c, brandBindings + 0, 2, false}, }; template -const ::capnp::_::RawBrandedSchema::Binding - Map::_capnpPrivate::brandBindings[] = { - ::capnp::_::brandBindingFor(), - ::capnp::_::brandBindingFor(), +const ::capnp::_::RawBrandedSchema::Binding Map::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), }; template -const ::capnp::_::RawBrandedSchema::Dependency - Map::_capnpPrivate::brandDependencies[] = { - {16777216, - ::tiledb::sm::serialization::capnp::Map::Entry:: - _capnpPrivate::brand()}, +const ::capnp::_::RawBrandedSchema::Dependency Map::_capnpPrivate::brandDependencies[] = { + { 16777216, ::tiledb::sm::serialization::capnp::Map::Entry::_capnpPrivate::brand() }, }; template -const ::capnp::_::RawBrandedSchema - Map::_capnpPrivate::specificBrand = { - &::capnp::schemas::s_f179c194ae71718c, - brandScopes, - brandDependencies, - 1, - 1, - nullptr}; +const ::capnp::_::RawBrandedSchema Map::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_f179c194ae71718c, brandScopes, brandDependencies, + 1, 1, nullptr +}; #endif // !CAPNP_LITE inline bool MapEnumeration::Reader::hasEntries() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool MapEnumeration::Builder::hasEntries() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>::Reader -MapEnumeration::Reader::getEntries() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>::Builder -MapEnumeration::Builder::getEntries() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void MapEnumeration::Builder::setEntries( - ::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>::Builder -MapEnumeration::Builder::initEntries(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>::Reader MapEnumeration::Reader::getEntries() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>::Builder MapEnumeration::Builder::getEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void MapEnumeration::Builder::setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>::Builder MapEnumeration::Builder::initEntries(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void MapEnumeration::Builder::adoptEntries( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>> -MapEnumeration::Builder::disownEntries() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>> MapEnumeration::Builder::disownEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool MapEnumeration::Entry::Reader::hasKey() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool MapEnumeration::Entry::Builder::hasKey() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader MapEnumeration::Entry::Reader::getKey() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader MapEnumeration::Entry::Reader::getKey() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder MapEnumeration::Entry::Builder::getKey() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder MapEnumeration::Entry::Builder::getKey() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void MapEnumeration::Entry::Builder::setKey( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void MapEnumeration::Entry::Builder::setKey( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder MapEnumeration::Entry::Builder::initKey( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder MapEnumeration::Entry::Builder::initKey(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void MapEnumeration::Entry::Builder::adoptKey( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -MapEnumeration::Entry::Builder::disownKey() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> MapEnumeration::Entry::Builder::disownKey() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool MapEnumeration::Entry::Reader::hasValue() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool MapEnumeration::Entry::Builder::hasValue() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader -MapEnumeration::Entry::Reader::getValue() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder -MapEnumeration::Entry::Builder::getValue() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline void MapEnumeration::Entry::Builder::setValue( - ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder -MapEnumeration::Entry::Builder::initValue(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader MapEnumeration::Entry::Reader::getValue() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder MapEnumeration::Entry::Builder::getValue() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void MapEnumeration::Entry::Builder::setValue( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder MapEnumeration::Entry::Builder::initValue(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void MapEnumeration::Entry::Builder::adoptValue( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>> -MapEnumeration::Entry::Builder::disownValue() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> MapEnumeration::Entry::Builder::disownValue() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool MapUInt32::Reader::hasEntries() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool MapUInt32::Builder::hasEntries() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>::Reader -MapUInt32::Reader::getEntries() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>::Builder -MapUInt32::Builder::getEntries() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void MapUInt32::Builder::setEntries( - ::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>::Builder -MapUInt32::Builder::initEntries(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>::Reader MapUInt32::Reader::getEntries() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>::Builder MapUInt32::Builder::getEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void MapUInt32::Builder::setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>::Builder MapUInt32::Builder::initEntries(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void MapUInt32::Builder::adoptEntries( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>> -MapUInt32::Builder::disownEntries() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt32::Entry, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>> MapUInt32::Builder::disownEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool MapUInt32::Entry::Reader::hasKey() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool MapUInt32::Entry::Builder::hasKey() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader MapUInt32::Entry::Reader::getKey() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader MapUInt32::Entry::Reader::getKey() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder MapUInt32::Entry::Builder::getKey() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder MapUInt32::Entry::Builder::getKey() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void MapUInt32::Entry::Builder::setKey(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void MapUInt32::Entry::Builder::setKey( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder MapUInt32::Entry::Builder::initKey( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder MapUInt32::Entry::Builder::initKey(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void MapUInt32::Entry::Builder::adoptKey( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> MapUInt32::Entry::Builder::disownKey() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> MapUInt32::Entry::Builder::disownKey() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint32_t MapUInt32::Entry::Reader::getValue() const { - return _reader.getDataField<::uint32_t>( +inline ::uint32_t MapUInt32::Entry::Reader::getValue() const { + return _reader.getDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint32_t MapUInt32::Entry::Builder::getValue() { - return _builder.getDataField<::uint32_t>( +inline ::uint32_t MapUInt32::Entry::Builder::getValue() { + return _builder.getDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void MapUInt32::Entry::Builder::setValue(::uint32_t value) { - _builder.setDataField<::uint32_t>( +inline void MapUInt32::Entry::Builder::setValue( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool MapInt64::Reader::hasEntries() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool MapInt64::Builder::hasEntries() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>::Reader -MapInt64::Reader::getEntries() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>::Builder -MapInt64::Builder::getEntries() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void MapInt64::Builder::setEntries( - ::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>::Builder -MapInt64::Builder::initEntries(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>::Reader MapInt64::Reader::getEntries() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>::Builder MapInt64::Builder::getEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void MapInt64::Builder::setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>::Builder MapInt64::Builder::initEntries(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void MapInt64::Builder::adoptEntries( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>> -MapInt64::Builder::disownEntries() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapInt64::Entry, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>> MapInt64::Builder::disownEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool MapInt64::Entry::Reader::hasKey() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool MapInt64::Entry::Builder::hasKey() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader MapInt64::Entry::Reader::getKey() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader MapInt64::Entry::Reader::getKey() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder MapInt64::Entry::Builder::getKey() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder MapInt64::Entry::Builder::getKey() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void MapInt64::Entry::Builder::setKey(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void MapInt64::Entry::Builder::setKey( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder MapInt64::Entry::Builder::initKey( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder MapInt64::Entry::Builder::initKey(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void MapInt64::Entry::Builder::adoptKey( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> MapInt64::Entry::Builder::disownKey() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> MapInt64::Entry::Builder::disownKey() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::int64_t MapInt64::Entry::Reader::getValue() const { - return _reader.getDataField<::int64_t>( +inline ::int64_t MapInt64::Entry::Reader::getValue() const { + return _reader.getDataField< ::int64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::int64_t MapInt64::Entry::Builder::getValue() { - return _builder.getDataField<::int64_t>( +inline ::int64_t MapInt64::Entry::Builder::getValue() { + return _builder.getDataField< ::int64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void MapInt64::Entry::Builder::setValue(::int64_t value) { - _builder.setDataField<::int64_t>( +inline void MapInt64::Entry::Builder::setValue( ::int64_t value) { + _builder.setDataField< ::int64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool MapUInt64::Reader::hasEntries() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool MapUInt64::Builder::hasEntries() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>::Reader -MapUInt64::Reader::getEntries() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>::Builder -MapUInt64::Builder::getEntries() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void MapUInt64::Builder::setEntries( - ::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>::Builder -MapUInt64::Builder::initEntries(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>::Reader MapUInt64::Reader::getEntries() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>::Builder MapUInt64::Builder::getEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void MapUInt64::Builder::setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>::Builder MapUInt64::Builder::initEntries(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void MapUInt64::Builder::adoptEntries( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>> -MapUInt64::Builder::disownEntries() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapUInt64::Entry, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>> MapUInt64::Builder::disownEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool MapUInt64::Entry::Reader::hasKey() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool MapUInt64::Entry::Builder::hasKey() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader MapUInt64::Entry::Reader::getKey() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader MapUInt64::Entry::Reader::getKey() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder MapUInt64::Entry::Builder::getKey() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder MapUInt64::Entry::Builder::getKey() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void MapUInt64::Entry::Builder::setKey(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void MapUInt64::Entry::Builder::setKey( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder MapUInt64::Entry::Builder::initKey( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder MapUInt64::Entry::Builder::initKey(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void MapUInt64::Entry::Builder::adoptKey( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> MapUInt64::Entry::Builder::disownKey() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> MapUInt64::Entry::Builder::disownKey() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t MapUInt64::Entry::Reader::getValue() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t MapUInt64::Entry::Reader::getValue() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t MapUInt64::Entry::Builder::getValue() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t MapUInt64::Entry::Builder::getValue() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void MapUInt64::Entry::Builder::setValue(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void MapUInt64::Entry::Builder::setValue( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool MapFloat64::Reader::hasEntries() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool MapFloat64::Builder::hasEntries() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>::Reader -MapFloat64::Reader::getEntries() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>::Builder -MapFloat64::Builder::getEntries() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void MapFloat64::Builder::setEntries( - ::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>::Builder -MapFloat64::Builder::initEntries(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>::Reader MapFloat64::Reader::getEntries() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>::Builder MapFloat64::Builder::getEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void MapFloat64::Builder::setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>::Builder MapFloat64::Builder::initEntries(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void MapFloat64::Builder::adoptEntries( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>> -MapFloat64::Builder::disownEntries() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::MapFloat64::Entry, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>> MapFloat64::Builder::disownEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool MapFloat64::Entry::Reader::hasKey() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool MapFloat64::Entry::Builder::hasKey() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader MapFloat64::Entry::Reader::getKey() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader MapFloat64::Entry::Reader::getKey() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder MapFloat64::Entry::Builder::getKey() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder MapFloat64::Entry::Builder::getKey() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void MapFloat64::Entry::Builder::setKey(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void MapFloat64::Entry::Builder::setKey( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder MapFloat64::Entry::Builder::initKey( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder MapFloat64::Entry::Builder::initKey(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void MapFloat64::Entry::Builder::adoptKey( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> MapFloat64::Entry::Builder::disownKey() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> MapFloat64::Entry::Builder::disownKey() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline double MapFloat64::Entry::Reader::getValue() const { @@ -22461,1276 +17127,910 @@ inline void MapFloat64::Entry::Builder::setValue(double value) { } inline bool Stats::Reader::hasTimers() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool Stats::Builder::hasTimers() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::MapFloat64::Reader -Stats::Reader::getTimers() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::MapFloat64>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapFloat64::Reader Stats::Reader::getTimers() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapFloat64>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::MapFloat64::Builder -Stats::Builder::getTimers() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::MapFloat64>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapFloat64::Builder Stats::Builder::getTimers() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapFloat64>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::MapFloat64::Pipeline -Stats::Pipeline::getTimers() { - return ::tiledb::sm::serialization::capnp::MapFloat64::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::MapFloat64::Pipeline Stats::Pipeline::getTimers() { + return ::tiledb::sm::serialization::capnp::MapFloat64::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void Stats::Builder::setTimers( - ::tiledb::sm::serialization::capnp::MapFloat64::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::MapFloat64>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void Stats::Builder::setTimers( ::tiledb::sm::serialization::capnp::MapFloat64::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapFloat64>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::MapFloat64::Builder -Stats::Builder::initTimers() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::MapFloat64>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapFloat64::Builder Stats::Builder::initTimers() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapFloat64>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void Stats::Builder::adoptTimers( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapFloat64>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::MapFloat64>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapFloat64>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapFloat64>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapFloat64> -Stats::Builder::disownTimers() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::MapFloat64>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapFloat64> Stats::Builder::disownTimers() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapFloat64>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Stats::Reader::hasCounters() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool Stats::Builder::hasCounters() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::MapUInt64::Reader -Stats::Reader::getCounters() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapUInt64::Reader Stats::Reader::getCounters() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder -Stats::Builder::getCounters() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder Stats::Builder::getCounters() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline -Stats::Pipeline::getCounters() { - return ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline( - _typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline Stats::Pipeline::getCounters() { + return ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline(_typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void Stats::Builder::setCounters( - ::tiledb::sm::serialization::capnp::MapUInt64::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>:: - set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void Stats::Builder::setCounters( ::tiledb::sm::serialization::capnp::MapUInt64::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder -Stats::Builder::initCounters() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder Stats::Builder::initCounters() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void Stats::Builder::adoptCounters( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapUInt64>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapUInt64>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapUInt64> -Stats::Builder::disownCounters() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapUInt64> Stats::Builder::disownCounters() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool UnorderedWriterState::Reader::getIsCoordsPass() const { - return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool UnorderedWriterState::Builder::getIsCoordsPass() { - return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void UnorderedWriterState::Builder::setIsCoordsPass(bool value) { - _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool UnorderedWriterState::Reader::hasCellPos() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool UnorderedWriterState::Builder::hasCellPos() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -UnorderedWriterState::Reader::getCellPos() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -UnorderedWriterState::Builder::getCellPos() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void UnorderedWriterState::Builder::setCellPos( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline void UnorderedWriterState::Builder::setCellPos( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -UnorderedWriterState::Builder::initCellPos(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader UnorderedWriterState::Reader::getCellPos() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder UnorderedWriterState::Builder::getCellPos() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void UnorderedWriterState::Builder::setCellPos( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline void UnorderedWriterState::Builder::setCellPos(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder UnorderedWriterState::Builder::initCellPos(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void UnorderedWriterState::Builder::adoptCellPos( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -UnorderedWriterState::Builder::disownCellPos() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> UnorderedWriterState::Builder::disownCellPos() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool UnorderedWriterState::Reader::hasCoordDups() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool UnorderedWriterState::Builder::hasCoordDups() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -UnorderedWriterState::Reader::getCoordDups() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -UnorderedWriterState::Builder::getCoordDups() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void UnorderedWriterState::Builder::setCoordDups( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline void UnorderedWriterState::Builder::setCoordDups( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -UnorderedWriterState::Builder::initCoordDups(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader UnorderedWriterState::Reader::getCoordDups() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder UnorderedWriterState::Builder::getCoordDups() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void UnorderedWriterState::Builder::setCoordDups( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline void UnorderedWriterState::Builder::setCoordDups(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder UnorderedWriterState::Builder::initCoordDups(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void UnorderedWriterState::Builder::adoptCoordDups( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -UnorderedWriterState::Builder::disownCoordDups() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> UnorderedWriterState::Builder::disownCoordDups() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool UnorderedWriterState::Reader::hasFragMeta() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool UnorderedWriterState::Builder::hasFragMeta() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader -UnorderedWriterState::Reader::getFragMeta() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader UnorderedWriterState::Reader::getFragMeta() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder -UnorderedWriterState::Builder::getFragMeta() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder UnorderedWriterState::Builder::getFragMeta() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline -UnorderedWriterState::Pipeline::getFragMeta() { - return ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline( - _typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline UnorderedWriterState::Pipeline::getFragMeta() { + return ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline(_typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void UnorderedWriterState::Builder::setFragMeta( - ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void UnorderedWriterState::Builder::setFragMeta( ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder -UnorderedWriterState::Builder::initFragMeta() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::FragmentMetadata>:: - init(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder UnorderedWriterState::Builder::initFragMeta() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void UnorderedWriterState::Builder::adoptFragMeta( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata>&& - value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::FragmentMetadata>:: - adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata> -UnorderedWriterState::Builder::disownFragMeta() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::FragmentMetadata>:: - disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata> UnorderedWriterState::Builder::disownFragMeta() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Writer::Reader::getCheckCoordDups() const { - return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool Writer::Builder::getCheckCoordDups() { - return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void Writer::Builder::setCheckCoordDups(bool value) { - _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool Writer::Reader::getCheckCoordOOB() const { - return _reader.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline bool Writer::Builder::getCheckCoordOOB() { - return _builder.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline void Writer::Builder::setCheckCoordOOB(bool value) { - _builder.setDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool Writer::Reader::getDedupCoords() const { - return _reader.getDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); } inline bool Writer::Builder::getDedupCoords() { - return _builder.getDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); } inline void Writer::Builder::setDedupCoords(bool value) { - _builder.setDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool Writer::Reader::hasSubarray() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool Writer::Builder::hasSubarray() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Reader -Writer::Reader::getSubarray() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Reader Writer::Reader::getSubarray() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Builder -Writer::Builder::getSubarray() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Builder Writer::Builder::getSubarray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline -Writer::Pipeline::getSubarray() { - return ::tiledb::sm::serialization::capnp::DomainArray::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline Writer::Pipeline::getSubarray() { + return ::tiledb::sm::serialization::capnp::DomainArray::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void Writer::Builder::setSubarray( - ::tiledb::sm::serialization::capnp::DomainArray::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void Writer::Builder::setSubarray( ::tiledb::sm::serialization::capnp::DomainArray::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Builder -Writer::Builder::initSubarray() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Builder Writer::Builder::initSubarray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void Writer::Builder::adoptSubarray( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray> -Writer::Builder::disownSubarray() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray> Writer::Builder::disownSubarray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Writer::Reader::hasSubarrayRanges() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool Writer::Builder::hasSubarrayRanges() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Subarray::Reader -Writer::Reader::getSubarrayRanges() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Reader Writer::Reader::getSubarrayRanges() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder -Writer::Builder::getSubarrayRanges() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder Writer::Builder::getSubarrayRanges() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline -Writer::Pipeline::getSubarrayRanges() { - return ::tiledb::sm::serialization::capnp::Subarray::Pipeline( - _typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline Writer::Pipeline::getSubarrayRanges() { + return ::tiledb::sm::serialization::capnp::Subarray::Pipeline(_typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void Writer::Builder::setSubarrayRanges( - ::tiledb::sm::serialization::capnp::Subarray::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void Writer::Builder::setSubarrayRanges( ::tiledb::sm::serialization::capnp::Subarray::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder -Writer::Builder::initSubarrayRanges() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder Writer::Builder::initSubarrayRanges() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void Writer::Builder::adoptSubarrayRanges( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> -Writer::Builder::disownSubarrayRanges() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> Writer::Builder::disownSubarrayRanges() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Writer::Reader::hasStats() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool Writer::Builder::hasStats() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Stats::Reader -Writer::Reader::getStats() const { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - get(_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Reader Writer::Reader::getStats() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder -Writer::Builder::getStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - get(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder Writer::Builder::getStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Stats::Pipeline -Writer::Pipeline::getStats() { - return ::tiledb::sm::serialization::capnp::Stats::Pipeline( - _typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::Stats::Pipeline Writer::Pipeline::getStats() { + return ::tiledb::sm::serialization::capnp::Stats::Pipeline(_typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void Writer::Builder::setStats( - ::tiledb::sm::serialization::capnp::Stats::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void Writer::Builder::setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder -Writer::Builder::initStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - init(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder Writer::Builder::initStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void Writer::Builder::adoptStats( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> -Writer::Builder::disownStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> Writer::Builder::disownStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Writer::Reader::hasGlobalWriteStateV1() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool Writer::Builder::hasGlobalWriteStateV1() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Reader -Writer::Reader::getGlobalWriteStateV1() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::GlobalWriteState>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Reader Writer::Reader::getGlobalWriteStateV1() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GlobalWriteState>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Builder -Writer::Builder::getGlobalWriteStateV1() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::GlobalWriteState>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Builder Writer::Builder::getGlobalWriteStateV1() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GlobalWriteState>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Pipeline -Writer::Pipeline::getGlobalWriteStateV1() { - return ::tiledb::sm::serialization::capnp::GlobalWriteState::Pipeline( - _typeless.getPointerField(3)); +inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Pipeline Writer::Pipeline::getGlobalWriteStateV1() { + return ::tiledb::sm::serialization::capnp::GlobalWriteState::Pipeline(_typeless.getPointerField(3)); } #endif // !CAPNP_LITE -inline void Writer::Builder::setGlobalWriteStateV1( - ::tiledb::sm::serialization::capnp::GlobalWriteState::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::GlobalWriteState>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); +inline void Writer::Builder::setGlobalWriteStateV1( ::tiledb::sm::serialization::capnp::GlobalWriteState::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GlobalWriteState>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Builder -Writer::Builder::initGlobalWriteStateV1() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::GlobalWriteState>:: - init(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Builder Writer::Builder::initGlobalWriteStateV1() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GlobalWriteState>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void Writer::Builder::adoptGlobalWriteStateV1( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::GlobalWriteState>&& - value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::GlobalWriteState>:: - adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::GlobalWriteState> -Writer::Builder::disownGlobalWriteStateV1() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::GlobalWriteState>:: - disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GlobalWriteState>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GlobalWriteState>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GlobalWriteState> Writer::Builder::disownGlobalWriteStateV1() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GlobalWriteState>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool Writer::Reader::hasUnorderedWriterState() const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool Writer::Builder::hasUnorderedWriterState() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Reader -Writer::Reader::getUnorderedWriterState() const { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::UnorderedWriterState>:: - get(_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Reader Writer::Reader::getUnorderedWriterState() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::UnorderedWriterState>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Builder -Writer::Builder::getUnorderedWriterState() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::UnorderedWriterState>:: - get(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Builder Writer::Builder::getUnorderedWriterState() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::UnorderedWriterState>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Pipeline -Writer::Pipeline::getUnorderedWriterState() { - return ::tiledb::sm::serialization::capnp::UnorderedWriterState::Pipeline( - _typeless.getPointerField(4)); +inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Pipeline Writer::Pipeline::getUnorderedWriterState() { + return ::tiledb::sm::serialization::capnp::UnorderedWriterState::Pipeline(_typeless.getPointerField(4)); } #endif // !CAPNP_LITE -inline void Writer::Builder::setUnorderedWriterState( - ::tiledb::sm::serialization::capnp::UnorderedWriterState::Reader value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::UnorderedWriterState>:: - set(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); +inline void Writer::Builder::setUnorderedWriterState( ::tiledb::sm::serialization::capnp::UnorderedWriterState::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::UnorderedWriterState>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Builder -Writer::Builder::initUnorderedWriterState() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::UnorderedWriterState>:: - init(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Builder Writer::Builder::initUnorderedWriterState() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::UnorderedWriterState>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline void Writer::Builder::adoptUnorderedWriterState( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::UnorderedWriterState>&& - value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::UnorderedWriterState>:: - adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::UnorderedWriterState> -Writer::Builder::disownUnorderedWriterState() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::UnorderedWriterState>:: - disown( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::UnorderedWriterState>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::UnorderedWriterState>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::UnorderedWriterState> Writer::Builder::disownUnorderedWriterState() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::UnorderedWriterState>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool SubarrayRanges::Reader::hasType() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool SubarrayRanges::Builder::hasType() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader SubarrayRanges::Reader::getType() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader SubarrayRanges::Reader::getType() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder SubarrayRanges::Builder::getType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder SubarrayRanges::Builder::getType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void SubarrayRanges::Builder::setType(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void SubarrayRanges::Builder::setType( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder SubarrayRanges::Builder::initType( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder SubarrayRanges::Builder::initType(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void SubarrayRanges::Builder::adoptType( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> SubarrayRanges::Builder::disownType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> SubarrayRanges::Builder::disownType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool SubarrayRanges::Reader::getHasDefaultRange() const { - return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool SubarrayRanges::Builder::getHasDefaultRange() { - return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void SubarrayRanges::Builder::setHasDefaultRange(bool value) { - _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool SubarrayRanges::Reader::hasBuffer() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool SubarrayRanges::Builder::hasBuffer() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Data::Reader SubarrayRanges::Reader::getBuffer() const { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Data::Reader SubarrayRanges::Reader::getBuffer() const { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Data::Builder SubarrayRanges::Builder::getBuffer() { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Data::Builder SubarrayRanges::Builder::getBuffer() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void SubarrayRanges::Builder::setBuffer(::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Data>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void SubarrayRanges::Builder::setBuffer( ::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::capnp::Data::Builder SubarrayRanges::Builder::initBuffer( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Data>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); +inline ::capnp::Data::Builder SubarrayRanges::Builder::initBuffer(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void SubarrayRanges::Builder::adoptBuffer( - ::capnp::Orphan<::capnp::Data>&& value) { - ::capnp::_::PointerHelpers<::capnp::Data>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Data>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Data> SubarrayRanges::Builder::disownBuffer() { - return ::capnp::_::PointerHelpers<::capnp::Data>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Data> SubarrayRanges::Builder::disownBuffer() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool SubarrayRanges::Reader::hasBufferSizes() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool SubarrayRanges::Builder::hasBufferSizes() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -SubarrayRanges::Reader::getBufferSizes() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -SubarrayRanges::Builder::getBufferSizes() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void SubarrayRanges::Builder::setBufferSizes( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline void SubarrayRanges::Builder::setBufferSizes( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -SubarrayRanges::Builder::initBufferSizes(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader SubarrayRanges::Reader::getBufferSizes() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder SubarrayRanges::Builder::getBufferSizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void SubarrayRanges::Builder::setBufferSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline void SubarrayRanges::Builder::setBufferSizes(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder SubarrayRanges::Builder::initBufferSizes(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void SubarrayRanges::Builder::adoptBufferSizes( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -SubarrayRanges::Builder::disownBufferSizes() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> SubarrayRanges::Builder::disownBufferSizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool SubarrayRanges::Reader::hasBufferStartSizes() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool SubarrayRanges::Builder::hasBufferStartSizes() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -SubarrayRanges::Reader::getBufferStartSizes() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -SubarrayRanges::Builder::getBufferStartSizes() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline void SubarrayRanges::Builder::setBufferStartSizes( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline void SubarrayRanges::Builder::setBufferStartSizes( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -SubarrayRanges::Builder::initBufferStartSizes(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader SubarrayRanges::Reader::getBufferStartSizes() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder SubarrayRanges::Builder::getBufferStartSizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void SubarrayRanges::Builder::setBufferStartSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline void SubarrayRanges::Builder::setBufferStartSizes(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder SubarrayRanges::Builder::initBufferStartSizes(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); } inline void SubarrayRanges::Builder::adoptBufferStartSizes( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -SubarrayRanges::Builder::disownBufferStartSizes() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} - -inline ::uint32_t LabelSubarrayRanges::Reader::getDimensionId() const { - return _reader.getDataField<::uint32_t>( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> SubarrayRanges::Builder::disownBufferStartSizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline ::uint32_t LabelSubarrayRanges::Reader::getDimensionId() const { + return _reader.getDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint32_t LabelSubarrayRanges::Builder::getDimensionId() { - return _builder.getDataField<::uint32_t>( +inline ::uint32_t LabelSubarrayRanges::Builder::getDimensionId() { + return _builder.getDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void LabelSubarrayRanges::Builder::setDimensionId(::uint32_t value) { - _builder.setDataField<::uint32_t>( +inline void LabelSubarrayRanges::Builder::setDimensionId( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool LabelSubarrayRanges::Reader::hasName() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool LabelSubarrayRanges::Builder::hasName() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader LabelSubarrayRanges::Reader::getName() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader LabelSubarrayRanges::Reader::getName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder LabelSubarrayRanges::Builder::getName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder LabelSubarrayRanges::Builder::getName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void LabelSubarrayRanges::Builder::setName(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void LabelSubarrayRanges::Builder::setName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder LabelSubarrayRanges::Builder::initName( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder LabelSubarrayRanges::Builder::initName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void LabelSubarrayRanges::Builder::adoptName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -LabelSubarrayRanges::Builder::disownName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> LabelSubarrayRanges::Builder::disownName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool LabelSubarrayRanges::Reader::hasRanges() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool LabelSubarrayRanges::Builder::hasRanges() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Reader -LabelSubarrayRanges::Reader::getRanges() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::SubarrayRanges>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Reader LabelSubarrayRanges::Reader::getRanges() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayRanges>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Builder -LabelSubarrayRanges::Builder::getRanges() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::SubarrayRanges>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Builder LabelSubarrayRanges::Builder::getRanges() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayRanges>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Pipeline -LabelSubarrayRanges::Pipeline::getRanges() { - return ::tiledb::sm::serialization::capnp::SubarrayRanges::Pipeline( - _typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Pipeline LabelSubarrayRanges::Pipeline::getRanges() { + return ::tiledb::sm::serialization::capnp::SubarrayRanges::Pipeline(_typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void LabelSubarrayRanges::Builder::setRanges( - ::tiledb::sm::serialization::capnp::SubarrayRanges::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::SubarrayRanges>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void LabelSubarrayRanges::Builder::setRanges( ::tiledb::sm::serialization::capnp::SubarrayRanges::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayRanges>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Builder -LabelSubarrayRanges::Builder::initRanges() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::SubarrayRanges>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Builder LabelSubarrayRanges::Builder::initRanges() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayRanges>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void LabelSubarrayRanges::Builder::adoptRanges( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayRanges>&& - value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::SubarrayRanges>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayRanges>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayRanges>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayRanges> -LabelSubarrayRanges::Builder::disownRanges() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayRanges>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayRanges> LabelSubarrayRanges::Builder::disownRanges() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayRanges>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Subarray::Reader::hasLayout() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool Subarray::Builder::hasLayout() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Subarray::Reader::getLayout() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Subarray::Reader::getLayout() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Subarray::Builder::getLayout() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Subarray::Builder::getLayout() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Subarray::Builder::setLayout(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void Subarray::Builder::setLayout( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Subarray::Builder::initLayout(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Subarray::Builder::initLayout(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void Subarray::Builder::adoptLayout( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Subarray::Builder::disownLayout() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Subarray::Builder::disownLayout() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Subarray::Reader::hasRanges() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool Subarray::Builder::hasRanges() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>::Reader -Subarray::Reader::getRanges() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>::Builder -Subarray::Builder::getRanges() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline void Subarray::Builder::setRanges( - ::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>::Builder -Subarray::Builder::initRanges(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Reader Subarray::Reader::getRanges() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Builder Subarray::Builder::getRanges() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void Subarray::Builder::setRanges( ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Builder Subarray::Builder::initRanges(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void Subarray::Builder::adoptRanges( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>> -Subarray::Builder::disownRanges() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>> Subarray::Builder::disownRanges() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Subarray::Reader::hasStats() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool Subarray::Builder::hasStats() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Stats::Reader -Subarray::Reader::getStats() const { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - get(_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Reader Subarray::Reader::getStats() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder -Subarray::Builder::getStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - get(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder Subarray::Builder::getStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Stats::Pipeline -Subarray::Pipeline::getStats() { - return ::tiledb::sm::serialization::capnp::Stats::Pipeline( - _typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::Stats::Pipeline Subarray::Pipeline::getStats() { + return ::tiledb::sm::serialization::capnp::Stats::Pipeline(_typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void Subarray::Builder::setStats( - ::tiledb::sm::serialization::capnp::Stats::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void Subarray::Builder::setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder -Subarray::Builder::initStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - init(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder Subarray::Builder::initStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void Subarray::Builder::adoptStats( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> -Subarray::Builder::disownStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> Subarray::Builder::disownStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Subarray::Reader::hasRelevantFragments() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool Subarray::Builder::hasRelevantFragments() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader -Subarray::Reader::getRelevantFragments() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder -Subarray::Builder::getRelevantFragments() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline void Subarray::Builder::setRelevantFragments( - ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline void Subarray::Builder::setRelevantFragments( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder -Subarray::Builder::initRelevantFragments(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader Subarray::Reader::getRelevantFragments() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder Subarray::Builder::getRelevantFragments() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void Subarray::Builder::setRelevantFragments( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline void Subarray::Builder::setRelevantFragments(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder Subarray::Builder::initRelevantFragments(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); } inline void Subarray::Builder::adoptRelevantFragments( - ::capnp::Orphan<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>> -Subarray::Builder::disownRelevantFragments() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> Subarray::Builder::disownRelevantFragments() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool Subarray::Reader::hasLabelRanges() const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool Subarray::Builder::hasLabelRanges() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>::Reader -Subarray::Reader::getLabelRanges() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<4>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>::Builder -Subarray::Builder::getLabelRanges() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<4>() * - ::capnp::POINTERS)); -} -inline void Subarray::Builder::setLabelRanges( - ::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>::Builder -Subarray::Builder::initLabelRanges(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>::Reader Subarray::Reader::getLabelRanges() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>::Builder Subarray::Builder::getLabelRanges() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void Subarray::Builder::setLabelRanges( ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>::Builder Subarray::Builder::initLabelRanges(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); } inline void Subarray::Builder::adoptLabelRanges( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>> -Subarray::Builder::disownLabelRanges() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<4>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>> Subarray::Builder::disownLabelRanges() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool Subarray::Reader::hasAttributeRanges() const { - return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } inline bool Subarray::Builder::hasAttributeRanges() { - return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); -} -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>::Reader -Subarray::Reader::getAttributeRanges() const { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>>:: - get(_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>::Builder -Subarray::Builder::getAttributeRanges() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>>:: - get(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>::Pipeline -Subarray::Pipeline::getAttributeRanges() { - return ::tiledb::sm::serialization::capnp:: - Map<::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>:: - Pipeline(_typeless.getPointerField(5)); -} -#endif // !CAPNP_LITE -inline void Subarray::Builder::setAttributeRanges( - ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>>:: - set(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - value); -} -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>::Builder -Subarray::Builder::initAttributeRanges() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>>:: - init(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Reader Subarray::Reader::getAttributeRanges() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Builder Subarray::Builder::getAttributeRanges() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Pipeline Subarray::Pipeline::getAttributeRanges() { + return ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Pipeline(_typeless.getPointerField(5)); +} +#endif // !CAPNP_LITE +inline void Subarray::Builder::setAttributeRanges( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Builder Subarray::Builder::initAttributeRanges() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } inline void Subarray::Builder::adoptAttributeRanges( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>>:: - adopt( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>> -Subarray::Builder::disownAttributeRanges() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::SubarrayRanges>>:: - disown( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>> Subarray::Builder::disownAttributeRanges() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool Subarray::Reader::getCoalesceRanges() const { @@ -23748,432 +18048,305 @@ inline void Subarray::Builder::setCoalesceRanges(bool value) { } inline bool SubarrayPartitioner::Reader::hasSubarray() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool SubarrayPartitioner::Builder::hasSubarray() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Subarray::Reader -SubarrayPartitioner::Reader::getSubarray() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Reader SubarrayPartitioner::Reader::getSubarray() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder -SubarrayPartitioner::Builder::getSubarray() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder SubarrayPartitioner::Builder::getSubarray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline -SubarrayPartitioner::Pipeline::getSubarray() { - return ::tiledb::sm::serialization::capnp::Subarray::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline SubarrayPartitioner::Pipeline::getSubarray() { + return ::tiledb::sm::serialization::capnp::Subarray::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void SubarrayPartitioner::Builder::setSubarray( - ::tiledb::sm::serialization::capnp::Subarray::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void SubarrayPartitioner::Builder::setSubarray( ::tiledb::sm::serialization::capnp::Subarray::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder -SubarrayPartitioner::Builder::initSubarray() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder SubarrayPartitioner::Builder::initSubarray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void SubarrayPartitioner::Builder::adoptSubarray( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> -SubarrayPartitioner::Builder::disownSubarray() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> SubarrayPartitioner::Builder::disownSubarray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool SubarrayPartitioner::Reader::hasBudget() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool SubarrayPartitioner::Builder::hasBudget() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>::Reader -SubarrayPartitioner::Reader::getBudget() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>::Builder -SubarrayPartitioner::Builder::getBudget() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline void SubarrayPartitioner::Builder::setBudget( - ::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>::Builder -SubarrayPartitioner::Builder::initBudget(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>::Reader SubarrayPartitioner::Reader::getBudget() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>::Builder SubarrayPartitioner::Builder::getBudget() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void SubarrayPartitioner::Builder::setBudget( ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>::Builder SubarrayPartitioner::Builder::initBudget(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void SubarrayPartitioner::Builder::adoptBudget( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>> -SubarrayPartitioner::Builder::disownBudget() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferSize, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>> SubarrayPartitioner::Builder::disownBudget() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool SubarrayPartitioner::Reader::hasCurrent() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool SubarrayPartitioner::Builder::hasCurrent() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); -} -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo:: - Reader - SubarrayPartitioner::Reader::getCurrent() const { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>:: - get(_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo:: - Builder - SubarrayPartitioner::Builder::getCurrent() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>:: - get(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo:: - Pipeline - SubarrayPartitioner::Pipeline::getCurrent() { - return ::tiledb::sm::serialization::capnp::SubarrayPartitioner:: - PartitionInfo::Pipeline(_typeless.getPointerField(2)); -} -#endif // !CAPNP_LITE -inline void SubarrayPartitioner::Builder::setCurrent( - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo:: - Reader value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>:: - set(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo:: - Builder - SubarrayPartitioner::Builder::initCurrent() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>:: - init(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Reader SubarrayPartitioner::Reader::getCurrent() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Builder SubarrayPartitioner::Builder::getCurrent() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Pipeline SubarrayPartitioner::Pipeline::getCurrent() { + return ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Pipeline(_typeless.getPointerField(2)); +} +#endif // !CAPNP_LITE +inline void SubarrayPartitioner::Builder::setCurrent( ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Builder SubarrayPartitioner::Builder::initCurrent() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void SubarrayPartitioner::Builder::adoptCurrent( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayPartitioner:: - PartitionInfo>&& value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>:: - adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo> -SubarrayPartitioner::Builder::disownCurrent() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>:: - disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo> SubarrayPartitioner::Builder::disownCurrent() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool SubarrayPartitioner::Reader::hasState() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool SubarrayPartitioner::Builder::hasState() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); -} -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Reader -SubarrayPartitioner::Reader::getState() const { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>:: - get(_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Builder -SubarrayPartitioner::Builder::getState() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>:: - get(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Pipeline -SubarrayPartitioner::Pipeline::getState() { - return ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State:: - Pipeline(_typeless.getPointerField(3)); -} -#endif // !CAPNP_LITE -inline void SubarrayPartitioner::Builder::setState( - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Reader - value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>:: - set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Builder -SubarrayPartitioner::Builder::initState() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>:: - init(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Reader SubarrayPartitioner::Reader::getState() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Builder SubarrayPartitioner::Builder::getState() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Pipeline SubarrayPartitioner::Pipeline::getState() { + return ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Pipeline(_typeless.getPointerField(3)); +} +#endif // !CAPNP_LITE +inline void SubarrayPartitioner::Builder::setState( ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Builder SubarrayPartitioner::Builder::initState() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void SubarrayPartitioner::Builder::adoptState( - ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>&& - value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>:: - adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State> -SubarrayPartitioner::Builder::disownState() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>:: - disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} - -inline ::uint64_t SubarrayPartitioner::Reader::getMemoryBudget() const { - return _reader.getDataField<::uint64_t>( + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State> SubarrayPartitioner::Builder::disownState() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline ::uint64_t SubarrayPartitioner::Reader::getMemoryBudget() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t SubarrayPartitioner::Builder::getMemoryBudget() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t SubarrayPartitioner::Builder::getMemoryBudget() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void SubarrayPartitioner::Builder::setMemoryBudget(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void SubarrayPartitioner::Builder::setMemoryBudget( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t SubarrayPartitioner::Reader::getMemoryBudgetVar() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t SubarrayPartitioner::Reader::getMemoryBudgetVar() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t SubarrayPartitioner::Builder::getMemoryBudgetVar() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t SubarrayPartitioner::Builder::getMemoryBudgetVar() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void SubarrayPartitioner::Builder::setMemoryBudgetVar(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void SubarrayPartitioner::Builder::setMemoryBudgetVar( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t SubarrayPartitioner::Reader::getMemoryBudgetValidity() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t SubarrayPartitioner::Reader::getMemoryBudgetValidity() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t SubarrayPartitioner::Builder::getMemoryBudgetValidity() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t SubarrayPartitioner::Builder::getMemoryBudgetValidity() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void SubarrayPartitioner::Builder::setMemoryBudgetValidity( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void SubarrayPartitioner::Builder::setMemoryBudgetValidity( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool SubarrayPartitioner::Reader::hasStats() const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool SubarrayPartitioner::Builder::hasStats() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Stats::Reader -SubarrayPartitioner::Reader::getStats() const { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - get(_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Reader SubarrayPartitioner::Reader::getStats() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder -SubarrayPartitioner::Builder::getStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - get(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder SubarrayPartitioner::Builder::getStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Stats::Pipeline -SubarrayPartitioner::Pipeline::getStats() { - return ::tiledb::sm::serialization::capnp::Stats::Pipeline( - _typeless.getPointerField(4)); +inline ::tiledb::sm::serialization::capnp::Stats::Pipeline SubarrayPartitioner::Pipeline::getStats() { + return ::tiledb::sm::serialization::capnp::Stats::Pipeline(_typeless.getPointerField(4)); } #endif // !CAPNP_LITE -inline void SubarrayPartitioner::Builder::setStats( - ::tiledb::sm::serialization::capnp::Stats::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); +inline void SubarrayPartitioner::Builder::setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder -SubarrayPartitioner::Builder::initStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - init(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder SubarrayPartitioner::Builder::initStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline void SubarrayPartitioner::Builder::adoptStats( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> -SubarrayPartitioner::Builder::disownStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - disown( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> SubarrayPartitioner::Builder::disownStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool SubarrayPartitioner::PartitionInfo::Reader::hasSubarray() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool SubarrayPartitioner::PartitionInfo::Builder::hasSubarray() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Subarray::Reader -SubarrayPartitioner::PartitionInfo::Reader::getSubarray() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Reader SubarrayPartitioner::PartitionInfo::Reader::getSubarray() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder -SubarrayPartitioner::PartitionInfo::Builder::getSubarray() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder SubarrayPartitioner::PartitionInfo::Builder::getSubarray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline -SubarrayPartitioner::PartitionInfo::Pipeline::getSubarray() { - return ::tiledb::sm::serialization::capnp::Subarray::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline SubarrayPartitioner::PartitionInfo::Pipeline::getSubarray() { + return ::tiledb::sm::serialization::capnp::Subarray::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void SubarrayPartitioner::PartitionInfo::Builder::setSubarray( - ::tiledb::sm::serialization::capnp::Subarray::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void SubarrayPartitioner::PartitionInfo::Builder::setSubarray( ::tiledb::sm::serialization::capnp::Subarray::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder -SubarrayPartitioner::PartitionInfo::Builder::initSubarray() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder SubarrayPartitioner::PartitionInfo::Builder::initSubarray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void SubarrayPartitioner::PartitionInfo::Builder::adoptSubarray( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> -SubarrayPartitioner::PartitionInfo::Builder::disownSubarray() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> SubarrayPartitioner::PartitionInfo::Builder::disownSubarray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t SubarrayPartitioner::PartitionInfo::Reader::getStart() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t SubarrayPartitioner::PartitionInfo::Reader::getStart() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t SubarrayPartitioner::PartitionInfo::Builder::getStart() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t SubarrayPartitioner::PartitionInfo::Builder::getStart() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void SubarrayPartitioner::PartitionInfo::Builder::setStart( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void SubarrayPartitioner::PartitionInfo::Builder::setStart( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t SubarrayPartitioner::PartitionInfo::Reader::getEnd() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t SubarrayPartitioner::PartitionInfo::Reader::getEnd() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t SubarrayPartitioner::PartitionInfo::Builder::getEnd() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t SubarrayPartitioner::PartitionInfo::Builder::getEnd() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void SubarrayPartitioner::PartitionInfo::Builder::setEnd( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void SubarrayPartitioner::PartitionInfo::Builder::setEnd( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline bool SubarrayPartitioner::PartitionInfo::Reader::getSplitMultiRange() - const { +inline bool SubarrayPartitioner::PartitionInfo::Reader::getSplitMultiRange() const { return _reader.getDataField( ::capnp::bounded<128>() * ::capnp::ELEMENTS); } @@ -24182,2137 +18355,1665 @@ inline bool SubarrayPartitioner::PartitionInfo::Builder::getSplitMultiRange() { return _builder.getDataField( ::capnp::bounded<128>() * ::capnp::ELEMENTS); } -inline void SubarrayPartitioner::PartitionInfo::Builder::setSplitMultiRange( - bool value) { +inline void SubarrayPartitioner::PartitionInfo::Builder::setSplitMultiRange(bool value) { _builder.setDataField( ::capnp::bounded<128>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t SubarrayPartitioner::State::Reader::getStart() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t SubarrayPartitioner::State::Reader::getStart() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t SubarrayPartitioner::State::Builder::getStart() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t SubarrayPartitioner::State::Builder::getStart() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void SubarrayPartitioner::State::Builder::setStart(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void SubarrayPartitioner::State::Builder::setStart( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t SubarrayPartitioner::State::Reader::getEnd() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t SubarrayPartitioner::State::Reader::getEnd() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t SubarrayPartitioner::State::Builder::getEnd() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t SubarrayPartitioner::State::Builder::getEnd() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void SubarrayPartitioner::State::Builder::setEnd(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void SubarrayPartitioner::State::Builder::setEnd( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool SubarrayPartitioner::State::Reader::hasSingleRange() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool SubarrayPartitioner::State::Builder::hasSingleRange() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>::Reader -SubarrayPartitioner::State::Reader::getSingleRange() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>::Builder -SubarrayPartitioner::State::Builder::getSingleRange() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void SubarrayPartitioner::State::Builder::setSingleRange( - ::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>::Builder -SubarrayPartitioner::State::Builder::initSingleRange(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Reader SubarrayPartitioner::State::Reader::getSingleRange() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Builder SubarrayPartitioner::State::Builder::getSingleRange() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void SubarrayPartitioner::State::Builder::setSingleRange( ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Builder SubarrayPartitioner::State::Builder::initSingleRange(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void SubarrayPartitioner::State::Builder::adoptSingleRange( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>> -SubarrayPartitioner::State::Builder::disownSingleRange() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>> SubarrayPartitioner::State::Builder::disownSingleRange() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool SubarrayPartitioner::State::Reader::hasMultiRange() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool SubarrayPartitioner::State::Builder::hasMultiRange() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>::Reader -SubarrayPartitioner::State::Reader::getMultiRange() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>::Builder -SubarrayPartitioner::State::Builder::getMultiRange() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline void SubarrayPartitioner::State::Builder::setMultiRange( - ::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>::Builder -SubarrayPartitioner::State::Builder::initMultiRange(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Reader SubarrayPartitioner::State::Reader::getMultiRange() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Builder SubarrayPartitioner::State::Builder::getMultiRange() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void SubarrayPartitioner::State::Builder::setMultiRange( ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Builder SubarrayPartitioner::State::Builder::initMultiRange(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void SubarrayPartitioner::State::Builder::adoptMultiRange( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>> -SubarrayPartitioner::State::Builder::disownMultiRange() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Subarray, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>> SubarrayPartitioner::State::Builder::disownMultiRange() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool ReadState::Reader::getOverflowed() const { - return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool ReadState::Builder::getOverflowed() { - return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void ReadState::Builder::setOverflowed(bool value) { - _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool ReadState::Reader::getUnsplittable() const { - return _reader.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline bool ReadState::Builder::getUnsplittable() { - return _builder.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline void ReadState::Builder::setUnsplittable(bool value) { - _builder.setDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool ReadState::Reader::getInitialized() const { - return _reader.getDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); } inline bool ReadState::Builder::getInitialized() { - return _builder.getDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); } inline void ReadState::Builder::setInitialized(bool value) { - _builder.setDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool ReadState::Reader::hasSubarrayPartitioner() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ReadState::Builder::hasSubarrayPartitioner() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Reader -ReadState::Reader::getSubarrayPartitioner() const { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner>:: - get(_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Reader ReadState::Reader::getSubarrayPartitioner() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Builder -ReadState::Builder::getSubarrayPartitioner() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner>:: - get(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Builder ReadState::Builder::getSubarrayPartitioner() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Pipeline -ReadState::Pipeline::getSubarrayPartitioner() { - return ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Pipeline ReadState::Pipeline::getSubarrayPartitioner() { + return ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void ReadState::Builder::setSubarrayPartitioner( - ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Reader value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void ReadState::Builder::setSubarrayPartitioner( ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Builder -ReadState::Builder::initSubarrayPartitioner() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner>:: - init(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Builder ReadState::Builder::initSubarrayPartitioner() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void ReadState::Builder::adoptSubarrayPartitioner( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayPartitioner>&& - value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayPartitioner> -ReadState::Builder::disownSubarrayPartitioner() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::SubarrayPartitioner>:: - disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner> ReadState::Builder::disownSubarrayPartitioner() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ConditionClause::Reader::hasFieldName() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ConditionClause::Builder::hasFieldName() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader ConditionClause::Reader::getFieldName() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ConditionClause::Reader::getFieldName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ConditionClause::Builder::getFieldName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ConditionClause::Builder::getFieldName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void ConditionClause::Builder::setFieldName( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void ConditionClause::Builder::setFieldName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder ConditionClause::Builder::initFieldName( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder ConditionClause::Builder::initFieldName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void ConditionClause::Builder::adoptFieldName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -ConditionClause::Builder::disownFieldName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> ConditionClause::Builder::disownFieldName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ConditionClause::Reader::hasValue() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool ConditionClause::Builder::hasValue() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Data::Reader ConditionClause::Reader::getValue() const { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Data::Reader ConditionClause::Reader::getValue() const { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Data::Builder ConditionClause::Builder::getValue() { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Data::Builder ConditionClause::Builder::getValue() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void ConditionClause::Builder::setValue(::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Data>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void ConditionClause::Builder::setValue( ::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::capnp::Data::Builder ConditionClause::Builder::initValue( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Data>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); +inline ::capnp::Data::Builder ConditionClause::Builder::initValue(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void ConditionClause::Builder::adoptValue( - ::capnp::Orphan<::capnp::Data>&& value) { - ::capnp::_::PointerHelpers<::capnp::Data>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Data>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Data> ConditionClause::Builder::disownValue() { - return ::capnp::_::PointerHelpers<::capnp::Data>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Data> ConditionClause::Builder::disownValue() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool ConditionClause::Reader::hasOp() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool ConditionClause::Builder::hasOp() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader ConditionClause::Reader::getOp() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ConditionClause::Reader::getOp() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ConditionClause::Builder::getOp() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ConditionClause::Builder::getOp() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void ConditionClause::Builder::setOp(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void ConditionClause::Builder::setOp( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder ConditionClause::Builder::initOp( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder ConditionClause::Builder::initOp(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void ConditionClause::Builder::adoptOp( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> ConditionClause::Builder::disownOp() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> ConditionClause::Builder::disownOp() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool ConditionClause::Reader::getUseEnumeration() const { - return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool ConditionClause::Builder::getUseEnumeration() { - return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void ConditionClause::Builder::setUseEnumeration(bool value) { - _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool ASTNode::Reader::getIsExpression() const { - return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool ASTNode::Builder::getIsExpression() { - return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void ASTNode::Builder::setIsExpression(bool value) { - _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool ASTNode::Reader::hasFieldName() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ASTNode::Builder::hasFieldName() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader ASTNode::Reader::getFieldName() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ASTNode::Reader::getFieldName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ASTNode::Builder::getFieldName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ASTNode::Builder::getFieldName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void ASTNode::Builder::setFieldName(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void ASTNode::Builder::setFieldName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder ASTNode::Builder::initFieldName( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder ASTNode::Builder::initFieldName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void ASTNode::Builder::adoptFieldName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> ASTNode::Builder::disownFieldName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> ASTNode::Builder::disownFieldName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ASTNode::Reader::hasValue() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool ASTNode::Builder::hasValue() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Data::Reader ASTNode::Reader::getValue() const { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Data::Reader ASTNode::Reader::getValue() const { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Data::Builder ASTNode::Builder::getValue() { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Data::Builder ASTNode::Builder::getValue() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void ASTNode::Builder::setValue(::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Data>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void ASTNode::Builder::setValue( ::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::capnp::Data::Builder ASTNode::Builder::initValue(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Data>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); +inline ::capnp::Data::Builder ASTNode::Builder::initValue(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void ASTNode::Builder::adoptValue( - ::capnp::Orphan<::capnp::Data>&& value) { - ::capnp::_::PointerHelpers<::capnp::Data>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Data>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Data> ASTNode::Builder::disownValue() { - return ::capnp::_::PointerHelpers<::capnp::Data>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Data> ASTNode::Builder::disownValue() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool ASTNode::Reader::hasOp() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool ASTNode::Builder::hasOp() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader ASTNode::Reader::getOp() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ASTNode::Reader::getOp() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ASTNode::Builder::getOp() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ASTNode::Builder::getOp() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void ASTNode::Builder::setOp(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void ASTNode::Builder::setOp( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder ASTNode::Builder::initOp(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder ASTNode::Builder::initOp(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } -inline void ASTNode::Builder::adoptOp(::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); +inline void ASTNode::Builder::adoptOp( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> ASTNode::Builder::disownOp() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> ASTNode::Builder::disownOp() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool ASTNode::Reader::hasChildren() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool ASTNode::Builder::hasChildren() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>::Reader -ASTNode::Reader::getChildren() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<3>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>::Builder -ASTNode::Builder::getChildren() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<3>() * - ::capnp::POINTERS)); -} -inline void ASTNode::Builder::setChildren( - ::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>::Builder -ASTNode::Builder::initChildren(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>::Reader ASTNode::Reader::getChildren() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>::Builder ASTNode::Builder::getChildren() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void ASTNode::Builder::setChildren( ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>::Builder ASTNode::Builder::initChildren(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); } inline void ASTNode::Builder::adoptChildren( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>> -ASTNode::Builder::disownChildren() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ASTNode, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<3>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>> ASTNode::Builder::disownChildren() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool ASTNode::Reader::hasCombinationOp() const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool ASTNode::Builder::hasCombinationOp() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader ASTNode::Reader::getCombinationOp() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ASTNode::Reader::getCombinationOp() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ASTNode::Builder::getCombinationOp() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ASTNode::Builder::getCombinationOp() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline void ASTNode::Builder::setCombinationOp(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); +inline void ASTNode::Builder::setCombinationOp( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder ASTNode::Builder::initCombinationOp( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder ASTNode::Builder::initCombinationOp(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); } inline void ASTNode::Builder::adoptCombinationOp( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> ASTNode::Builder::disownCombinationOp() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> ASTNode::Builder::disownCombinationOp() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool ASTNode::Reader::getUseEnumeration() const { - return _reader.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline bool ASTNode::Builder::getUseEnumeration() { - return _builder.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline void ASTNode::Builder::setUseEnumeration(bool value) { - _builder.setDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool ASTNode::Reader::hasOffsets() const { - return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } inline bool ASTNode::Builder::hasOffsets() { - return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Data::Reader ASTNode::Reader::getOffsets() const { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Data::Reader ASTNode::Reader::getOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline ::capnp::Data::Builder ASTNode::Builder::getOffsets() { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Data::Builder ASTNode::Builder::getOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline void ASTNode::Builder::setOffsets(::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Data>::set( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - value); +inline void ASTNode::Builder::setOffsets( ::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); } -inline ::capnp::Data::Builder ASTNode::Builder::initOffsets(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Data>::init( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - size); +inline ::capnp::Data::Builder ASTNode::Builder::initOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), size); } inline void ASTNode::Builder::adoptOffsets( - ::capnp::Orphan<::capnp::Data>&& value) { - ::capnp::_::PointerHelpers<::capnp::Data>::adopt( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Data>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Data> ASTNode::Builder::disownOffsets() { - return ::capnp::_::PointerHelpers<::capnp::Data>::disown( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Data> ASTNode::Builder::disownOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool Condition::Reader::hasClauses() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool Condition::Builder::hasClauses() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>::Reader -Condition::Reader::getClauses() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>::Builder -Condition::Builder::getClauses() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void Condition::Builder::setClauses( - ::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>::Builder -Condition::Builder::initClauses(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>::Reader Condition::Reader::getClauses() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>::Builder Condition::Builder::getClauses() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void Condition::Builder::setClauses( ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>::Builder Condition::Builder::initClauses(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void Condition::Builder::adoptClauses( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>> -Condition::Builder::disownClauses() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ConditionClause, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>> Condition::Builder::disownClauses() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Condition::Reader::hasClauseCombinationOps() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool Condition::Builder::hasClauseCombinationOps() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -Condition::Reader::getClauseCombinationOps() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -Condition::Builder::getClauseCombinationOps() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void Condition::Builder::setClauseCombinationOps( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline void Condition::Builder::setClauseCombinationOps( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -Condition::Builder::initClauseCombinationOps(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader Condition::Reader::getClauseCombinationOps() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder Condition::Builder::getClauseCombinationOps() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void Condition::Builder::setClauseCombinationOps( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline void Condition::Builder::setClauseCombinationOps(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder Condition::Builder::initClauseCombinationOps(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void Condition::Builder::adoptClauseCombinationOps( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -Condition::Builder::disownClauseCombinationOps() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> Condition::Builder::disownClauseCombinationOps() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Condition::Reader::hasTree() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool Condition::Builder::hasTree() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::ASTNode::Reader -Condition::Reader::getTree() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ASTNode>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ASTNode::Reader Condition::Reader::getTree() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ASTNode>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ASTNode::Builder -Condition::Builder::getTree() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ASTNode>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ASTNode::Builder Condition::Builder::getTree() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ASTNode>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ASTNode::Pipeline -Condition::Pipeline::getTree() { - return ::tiledb::sm::serialization::capnp::ASTNode::Pipeline( - _typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::ASTNode::Pipeline Condition::Pipeline::getTree() { + return ::tiledb::sm::serialization::capnp::ASTNode::Pipeline(_typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void Condition::Builder::setTree( - ::tiledb::sm::serialization::capnp::ASTNode::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ASTNode>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void Condition::Builder::setTree( ::tiledb::sm::serialization::capnp::ASTNode::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ASTNode>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::ASTNode::Builder -Condition::Builder::initTree() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ASTNode>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ASTNode::Builder Condition::Builder::initTree() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ASTNode>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void Condition::Builder::adoptTree( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ASTNode>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ASTNode>:: - adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ASTNode>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ASTNode>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ASTNode> -Condition::Builder::disownTree() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ASTNode>::disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ASTNode> Condition::Builder::disownTree() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ASTNode>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool QueryReader::Reader::hasLayout() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool QueryReader::Builder::hasLayout() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader QueryReader::Reader::getLayout() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader QueryReader::Reader::getLayout() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder QueryReader::Builder::getLayout() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder QueryReader::Builder::getLayout() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void QueryReader::Builder::setLayout(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void QueryReader::Builder::setLayout( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder QueryReader::Builder::initLayout( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder QueryReader::Builder::initLayout(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void QueryReader::Builder::adoptLayout( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> QueryReader::Builder::disownLayout() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> QueryReader::Builder::disownLayout() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool QueryReader::Reader::hasSubarray() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool QueryReader::Builder::hasSubarray() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Subarray::Reader -QueryReader::Reader::getSubarray() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Reader QueryReader::Reader::getSubarray() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder -QueryReader::Builder::getSubarray() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder QueryReader::Builder::getSubarray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline -QueryReader::Pipeline::getSubarray() { - return ::tiledb::sm::serialization::capnp::Subarray::Pipeline( - _typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline QueryReader::Pipeline::getSubarray() { + return ::tiledb::sm::serialization::capnp::Subarray::Pipeline(_typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void QueryReader::Builder::setSubarray( - ::tiledb::sm::serialization::capnp::Subarray::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void QueryReader::Builder::setSubarray( ::tiledb::sm::serialization::capnp::Subarray::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder -QueryReader::Builder::initSubarray() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder QueryReader::Builder::initSubarray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void QueryReader::Builder::adoptSubarray( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> -QueryReader::Builder::disownSubarray() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> QueryReader::Builder::disownSubarray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool QueryReader::Reader::hasReadState() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool QueryReader::Builder::hasReadState() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::ReadState::Reader -QueryReader::Reader::getReadState() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ReadState>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReadState::Reader QueryReader::Reader::getReadState() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadState>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ReadState::Builder -QueryReader::Builder::getReadState() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ReadState>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReadState::Builder QueryReader::Builder::getReadState() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadState>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ReadState::Pipeline -QueryReader::Pipeline::getReadState() { - return ::tiledb::sm::serialization::capnp::ReadState::Pipeline( - _typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::ReadState::Pipeline QueryReader::Pipeline::getReadState() { + return ::tiledb::sm::serialization::capnp::ReadState::Pipeline(_typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void QueryReader::Builder::setReadState( - ::tiledb::sm::serialization::capnp::ReadState::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ReadState>:: - set(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void QueryReader::Builder::setReadState( ::tiledb::sm::serialization::capnp::ReadState::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadState>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::ReadState::Builder -QueryReader::Builder::initReadState() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ReadState>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReadState::Builder QueryReader::Builder::initReadState() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadState>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void QueryReader::Builder::adoptReadState( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReadState>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ReadState>:: - adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReadState>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadState>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReadState> -QueryReader::Builder::disownReadState() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ReadState>::disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReadState> QueryReader::Builder::disownReadState() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadState>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool QueryReader::Reader::hasCondition() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool QueryReader::Builder::hasCondition() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Condition::Reader -QueryReader::Reader::getCondition() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Reader QueryReader::Reader::getCondition() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Condition::Builder -QueryReader::Builder::getCondition() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Builder QueryReader::Builder::getCondition() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Condition::Pipeline -QueryReader::Pipeline::getCondition() { - return ::tiledb::sm::serialization::capnp::Condition::Pipeline( - _typeless.getPointerField(3)); +inline ::tiledb::sm::serialization::capnp::Condition::Pipeline QueryReader::Pipeline::getCondition() { + return ::tiledb::sm::serialization::capnp::Condition::Pipeline(_typeless.getPointerField(3)); } #endif // !CAPNP_LITE -inline void QueryReader::Builder::setCondition( - ::tiledb::sm::serialization::capnp::Condition::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Condition>:: - set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); +inline void QueryReader::Builder::setCondition( ::tiledb::sm::serialization::capnp::Condition::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Condition::Builder -QueryReader::Builder::initCondition() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Builder QueryReader::Builder::initCondition() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void QueryReader::Builder::adoptCondition( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Condition>:: - adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition> -QueryReader::Builder::disownCondition() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition> QueryReader::Builder::disownCondition() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool QueryReader::Reader::hasStats() const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool QueryReader::Builder::hasStats() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Stats::Reader -QueryReader::Reader::getStats() const { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - get(_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Reader QueryReader::Reader::getStats() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder -QueryReader::Builder::getStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - get(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder QueryReader::Builder::getStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Stats::Pipeline -QueryReader::Pipeline::getStats() { - return ::tiledb::sm::serialization::capnp::Stats::Pipeline( - _typeless.getPointerField(4)); +inline ::tiledb::sm::serialization::capnp::Stats::Pipeline QueryReader::Pipeline::getStats() { + return ::tiledb::sm::serialization::capnp::Stats::Pipeline(_typeless.getPointerField(4)); } #endif // !CAPNP_LITE -inline void QueryReader::Builder::setStats( - ::tiledb::sm::serialization::capnp::Stats::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); +inline void QueryReader::Builder::setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder -QueryReader::Builder::initStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - init(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder QueryReader::Builder::initStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline void QueryReader::Builder::adoptStats( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> -QueryReader::Builder::disownStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - disown( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> QueryReader::Builder::disownStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool QueryReader::Reader::getDimLabelIncreasing() const { - return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool QueryReader::Builder::getDimLabelIncreasing() { - return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void QueryReader::Builder::setDimLabelIncreasing(bool value) { - _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool Delete::Reader::hasCondition() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool Delete::Builder::hasCondition() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Condition::Reader -Delete::Reader::getCondition() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Reader Delete::Reader::getCondition() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Condition::Builder -Delete::Builder::getCondition() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Builder Delete::Builder::getCondition() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Condition::Pipeline -Delete::Pipeline::getCondition() { - return ::tiledb::sm::serialization::capnp::Condition::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Condition::Pipeline Delete::Pipeline::getCondition() { + return ::tiledb::sm::serialization::capnp::Condition::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void Delete::Builder::setCondition( - ::tiledb::sm::serialization::capnp::Condition::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Condition>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void Delete::Builder::setCondition( ::tiledb::sm::serialization::capnp::Condition::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Condition::Builder -Delete::Builder::initCondition() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Builder Delete::Builder::initCondition() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void Delete::Builder::adoptCondition( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Condition>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition> -Delete::Builder::disownCondition() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition> Delete::Builder::disownCondition() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Delete::Reader::hasStats() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool Delete::Builder::hasStats() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Stats::Reader -Delete::Reader::getStats() const { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - get(_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Reader Delete::Reader::getStats() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder -Delete::Builder::getStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - get(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder Delete::Builder::getStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Stats::Pipeline -Delete::Pipeline::getStats() { - return ::tiledb::sm::serialization::capnp::Stats::Pipeline( - _typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::Stats::Pipeline Delete::Pipeline::getStats() { + return ::tiledb::sm::serialization::capnp::Stats::Pipeline(_typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void Delete::Builder::setStats( - ::tiledb::sm::serialization::capnp::Stats::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void Delete::Builder::setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder -Delete::Builder::initStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder Delete::Builder::initStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void Delete::Builder::adoptStats( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> -Delete::Builder::disownStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> Delete::Builder::disownStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::uint32_t ResultCellSlab::Reader::getFragIdx() const { - return _reader.getDataField<::uint32_t>( +inline ::uint32_t ResultCellSlab::Reader::getFragIdx() const { + return _reader.getDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint32_t ResultCellSlab::Builder::getFragIdx() { - return _builder.getDataField<::uint32_t>( +inline ::uint32_t ResultCellSlab::Builder::getFragIdx() { + return _builder.getDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ResultCellSlab::Builder::setFragIdx(::uint32_t value) { - _builder.setDataField<::uint32_t>( +inline void ResultCellSlab::Builder::setFragIdx( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t ResultCellSlab::Reader::getTileIdx() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t ResultCellSlab::Reader::getTileIdx() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t ResultCellSlab::Builder::getTileIdx() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t ResultCellSlab::Builder::getTileIdx() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void ResultCellSlab::Builder::setTileIdx(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void ResultCellSlab::Builder::setTileIdx( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t ResultCellSlab::Reader::getStart() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t ResultCellSlab::Reader::getStart() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t ResultCellSlab::Builder::getStart() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t ResultCellSlab::Builder::getStart() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void ResultCellSlab::Builder::setStart(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void ResultCellSlab::Builder::setStart( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t ResultCellSlab::Reader::getLength() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t ResultCellSlab::Reader::getLength() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS); } -inline ::uint64_t ResultCellSlab::Builder::getLength() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t ResultCellSlab::Builder::getLength() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS); } -inline void ResultCellSlab::Builder::setLength(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void ResultCellSlab::Builder::setLength( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t FragmentIndex::Reader::getTileIdx() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t FragmentIndex::Reader::getTileIdx() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t FragmentIndex::Builder::getTileIdx() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t FragmentIndex::Builder::getTileIdx() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void FragmentIndex::Builder::setTileIdx(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void FragmentIndex::Builder::setTileIdx( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t FragmentIndex::Reader::getCellIdx() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t FragmentIndex::Reader::getCellIdx() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t FragmentIndex::Builder::getCellIdx() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t FragmentIndex::Builder::getCellIdx() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void FragmentIndex::Builder::setCellIdx(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void FragmentIndex::Builder::setCellIdx( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool ReadStateIndex::Reader::hasResultCellSlab() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ReadStateIndex::Builder::hasResultCellSlab() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>::Reader -ReadStateIndex::Reader::getResultCellSlab() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>::Builder -ReadStateIndex::Builder::getResultCellSlab() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void ReadStateIndex::Builder::setResultCellSlab( - ::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>::Builder -ReadStateIndex::Builder::initResultCellSlab(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>::Reader ReadStateIndex::Reader::getResultCellSlab() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>::Builder ReadStateIndex::Builder::getResultCellSlab() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void ReadStateIndex::Builder::setResultCellSlab( ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>::Builder ReadStateIndex::Builder::initResultCellSlab(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void ReadStateIndex::Builder::adoptResultCellSlab( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>> -ReadStateIndex::Builder::disownResultCellSlab() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultCellSlab, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>> ReadStateIndex::Builder::disownResultCellSlab() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ReadStateIndex::Reader::hasFragTileIdx() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool ReadStateIndex::Builder::hasFragTileIdx() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>::Reader -ReadStateIndex::Reader::getFragTileIdx() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>::Builder -ReadStateIndex::Builder::getFragTileIdx() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline void ReadStateIndex::Builder::setFragTileIdx( - ::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>::Builder -ReadStateIndex::Builder::initFragTileIdx(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>::Reader ReadStateIndex::Reader::getFragTileIdx() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>::Builder ReadStateIndex::Builder::getFragTileIdx() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void ReadStateIndex::Builder::setFragTileIdx( ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>::Builder ReadStateIndex::Builder::initFragTileIdx(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void ReadStateIndex::Builder::adoptFragTileIdx( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>> -ReadStateIndex::Builder::disownFragTileIdx() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::FragmentIndex, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>> ReadStateIndex::Builder::disownFragTileIdx() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool ReadStateIndex::Reader::getDoneAddingResultTiles() const { - return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool ReadStateIndex::Builder::getDoneAddingResultTiles() { - return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void ReadStateIndex::Builder::setDoneAddingResultTiles(bool value) { - _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint64_t PreprocessTileOrder::Reader::getCursor() const { + return _reader.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t PreprocessTileOrder::Builder::getCursor() { + return _builder.getDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void PreprocessTileOrder::Builder::setCursor( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool ReaderIndex::Reader::hasLayout() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ReaderIndex::Builder::hasLayout() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader ReaderIndex::Reader::getLayout() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ReaderIndex::Reader::getLayout() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ReaderIndex::Builder::getLayout() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ReaderIndex::Builder::getLayout() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void ReaderIndex::Builder::setLayout(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void ReaderIndex::Builder::setLayout( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder ReaderIndex::Builder::initLayout( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder ReaderIndex::Builder::initLayout(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void ReaderIndex::Builder::adoptLayout( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> ReaderIndex::Builder::disownLayout() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> ReaderIndex::Builder::disownLayout() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ReaderIndex::Reader::hasSubarray() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool ReaderIndex::Builder::hasSubarray() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Subarray::Reader -ReaderIndex::Reader::getSubarray() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Reader ReaderIndex::Reader::getSubarray() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder -ReaderIndex::Builder::getSubarray() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder ReaderIndex::Builder::getSubarray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline -ReaderIndex::Pipeline::getSubarray() { - return ::tiledb::sm::serialization::capnp::Subarray::Pipeline( - _typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline ReaderIndex::Pipeline::getSubarray() { + return ::tiledb::sm::serialization::capnp::Subarray::Pipeline(_typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void ReaderIndex::Builder::setSubarray( - ::tiledb::sm::serialization::capnp::Subarray::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void ReaderIndex::Builder::setSubarray( ::tiledb::sm::serialization::capnp::Subarray::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder -ReaderIndex::Builder::initSubarray() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder ReaderIndex::Builder::initSubarray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void ReaderIndex::Builder::adoptSubarray( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> -ReaderIndex::Builder::disownSubarray() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> ReaderIndex::Builder::disownSubarray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool ReaderIndex::Reader::hasReadState() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool ReaderIndex::Builder::hasReadState() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Reader -ReaderIndex::Reader::getReadState() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ReadStateIndex>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Reader ReaderIndex::Reader::getReadState() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadStateIndex>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Builder -ReaderIndex::Builder::getReadState() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ReadStateIndex>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Builder ReaderIndex::Builder::getReadState() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadStateIndex>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Pipeline -ReaderIndex::Pipeline::getReadState() { - return ::tiledb::sm::serialization::capnp::ReadStateIndex::Pipeline( - _typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Pipeline ReaderIndex::Pipeline::getReadState() { + return ::tiledb::sm::serialization::capnp::ReadStateIndex::Pipeline(_typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void ReaderIndex::Builder::setReadState( - ::tiledb::sm::serialization::capnp::ReadStateIndex::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ReadStateIndex>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void ReaderIndex::Builder::setReadState( ::tiledb::sm::serialization::capnp::ReadStateIndex::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadStateIndex>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Builder -ReaderIndex::Builder::initReadState() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ReadStateIndex>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Builder ReaderIndex::Builder::initReadState() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadStateIndex>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void ReaderIndex::Builder::adoptReadState( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReadStateIndex>&& - value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ReadStateIndex>::adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReadStateIndex>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadStateIndex>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReadStateIndex> -ReaderIndex::Builder::disownReadState() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::ReadStateIndex>:: - disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReadStateIndex> ReaderIndex::Builder::disownReadState() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadStateIndex>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool ReaderIndex::Reader::hasCondition() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool ReaderIndex::Builder::hasCondition() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Condition::Reader -ReaderIndex::Reader::getCondition() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Reader ReaderIndex::Reader::getCondition() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Condition::Builder -ReaderIndex::Builder::getCondition() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Builder ReaderIndex::Builder::getCondition() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Condition::Pipeline -ReaderIndex::Pipeline::getCondition() { - return ::tiledb::sm::serialization::capnp::Condition::Pipeline( - _typeless.getPointerField(3)); +inline ::tiledb::sm::serialization::capnp::Condition::Pipeline ReaderIndex::Pipeline::getCondition() { + return ::tiledb::sm::serialization::capnp::Condition::Pipeline(_typeless.getPointerField(3)); } #endif // !CAPNP_LITE -inline void ReaderIndex::Builder::setCondition( - ::tiledb::sm::serialization::capnp::Condition::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Condition>:: - set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); +inline void ReaderIndex::Builder::setCondition( ::tiledb::sm::serialization::capnp::Condition::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Condition::Builder -ReaderIndex::Builder::initCondition() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Builder ReaderIndex::Builder::initCondition() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void ReaderIndex::Builder::adoptCondition( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Condition>:: - adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition> -ReaderIndex::Builder::disownCondition() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition> ReaderIndex::Builder::disownCondition() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool ReaderIndex::Reader::hasStats() const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool ReaderIndex::Builder::hasStats() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Stats::Reader -ReaderIndex::Reader::getStats() const { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - get(_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Reader ReaderIndex::Reader::getStats() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder -ReaderIndex::Builder::getStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - get(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder ReaderIndex::Builder::getStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Stats::Pipeline -ReaderIndex::Pipeline::getStats() { - return ::tiledb::sm::serialization::capnp::Stats::Pipeline( - _typeless.getPointerField(4)); +inline ::tiledb::sm::serialization::capnp::Stats::Pipeline ReaderIndex::Pipeline::getStats() { + return ::tiledb::sm::serialization::capnp::Stats::Pipeline(_typeless.getPointerField(4)); } #endif // !CAPNP_LITE -inline void ReaderIndex::Builder::setStats( - ::tiledb::sm::serialization::capnp::Stats::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); +inline void ReaderIndex::Builder::setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder -ReaderIndex::Builder::initStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - init(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder ReaderIndex::Builder::initStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline void ReaderIndex::Builder::adoptStats( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> ReaderIndex::Builder::disownStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} + +inline bool ReaderIndex::Reader::hasPreprocess() const { + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline bool ReaderIndex::Builder::hasPreprocess() { + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Reader ReaderIndex::Reader::getPreprocess() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::PreprocessTileOrder>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Builder ReaderIndex::Builder::getPreprocess() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::PreprocessTileOrder>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Pipeline ReaderIndex::Pipeline::getPreprocess() { + return ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Pipeline(_typeless.getPointerField(5)); +} +#endif // !CAPNP_LITE +inline void ReaderIndex::Builder::setPreprocess( ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::PreprocessTileOrder>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Builder ReaderIndex::Builder::initPreprocess() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::PreprocessTileOrder>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> -ReaderIndex::Builder::disownStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - disown( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline void ReaderIndex::Builder::adoptPreprocess( + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::PreprocessTileOrder>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::PreprocessTileOrder>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::PreprocessTileOrder> ReaderIndex::Builder::disownPreprocess() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::PreprocessTileOrder>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasAttributeBufferHeaders() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool Query::Builder::hasAttributeBufferHeaders() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>::Reader -Query::Reader::getAttributeBufferHeaders() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>::Builder -Query::Builder::getAttributeBufferHeaders() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void Query::Builder::setAttributeBufferHeaders( - ::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>::Builder -Query::Builder::initAttributeBufferHeaders(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>::Reader Query::Reader::getAttributeBufferHeaders() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>::Builder Query::Builder::getAttributeBufferHeaders() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void Query::Builder::setAttributeBufferHeaders( ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>::Builder Query::Builder::initAttributeBufferHeaders(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void Query::Builder::adoptAttributeBufferHeaders( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>> -Query::Builder::disownAttributeBufferHeaders() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::AttributeBufferHeader, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>> Query::Builder::disownAttributeBufferHeaders() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasLayout() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool Query::Builder::hasLayout() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Query::Reader::getLayout() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Query::Reader::getLayout() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Query::Builder::getLayout() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Query::Builder::getLayout() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void Query::Builder::setLayout(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void Query::Builder::setLayout( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Query::Builder::initLayout(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Query::Builder::initLayout(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void Query::Builder::adoptLayout( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Query::Builder::disownLayout() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Query::Builder::disownLayout() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasStatus() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool Query::Builder::hasStatus() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Query::Reader::getStatus() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Query::Reader::getStatus() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Query::Builder::getStatus() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Query::Builder::getStatus() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void Query::Builder::setStatus(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void Query::Builder::setStatus( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Query::Builder::initStatus(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Query::Builder::initStatus(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void Query::Builder::adoptStatus( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Query::Builder::disownStatus() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Query::Builder::disownStatus() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasType() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool Query::Builder::hasType() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Query::Reader::getType() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Query::Reader::getType() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Query::Builder::getType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Query::Builder::getType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline void Query::Builder::setType(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); +inline void Query::Builder::setType( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Query::Builder::initType(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Query::Builder::initType(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); } -inline void Query::Builder::adoptType(::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); +inline void Query::Builder::adoptType( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Query::Builder::disownType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Query::Builder::disownType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasWriter() const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool Query::Builder::hasWriter() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Writer::Reader -Query::Reader::getWriter() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Writer>::get( - _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Writer::Reader Query::Reader::getWriter() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Writer>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Writer::Builder -Query::Builder::getWriter() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Writer>::get( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Writer::Builder Query::Builder::getWriter() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Writer>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Writer::Pipeline -Query::Pipeline::getWriter() { - return ::tiledb::sm::serialization::capnp::Writer::Pipeline( - _typeless.getPointerField(4)); +inline ::tiledb::sm::serialization::capnp::Writer::Pipeline Query::Pipeline::getWriter() { + return ::tiledb::sm::serialization::capnp::Writer::Pipeline(_typeless.getPointerField(4)); } #endif // !CAPNP_LITE -inline void Query::Builder::setWriter( - ::tiledb::sm::serialization::capnp::Writer::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Writer>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); +inline void Query::Builder::setWriter( ::tiledb::sm::serialization::capnp::Writer::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Writer>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Writer::Builder -Query::Builder::initWriter() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Writer>::init( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Writer::Builder Query::Builder::initWriter() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Writer>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptWriter( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Writer>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Writer>::adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Writer>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Writer>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Writer> -Query::Builder::disownWriter() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Writer>::disown( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Writer> Query::Builder::disownWriter() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Writer>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasReader() const { - return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } inline bool Query::Builder::hasReader() { - return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Reader -Query::Reader::getReader() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::get( - _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Reader Query::Reader::getReader() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Builder -Query::Builder::getReader() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::get( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Builder Query::Builder::getReader() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline -Query::Pipeline::getReader() { - return ::tiledb::sm::serialization::capnp::QueryReader::Pipeline( - _typeless.getPointerField(5)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline Query::Pipeline::getReader() { + return ::tiledb::sm::serialization::capnp::QueryReader::Pipeline(_typeless.getPointerField(5)); } #endif // !CAPNP_LITE -inline void Query::Builder::setReader( - ::tiledb::sm::serialization::capnp::QueryReader::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>:: - set(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - value); +inline void Query::Builder::setReader( ::tiledb::sm::serialization::capnp::QueryReader::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Builder -Query::Builder::initReader() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::init( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Builder Query::Builder::initReader() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptReader( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>:: - adopt( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader> -Query::Builder::disownReader() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::disown( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader> Query::Builder::disownReader() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasArray() const { - return !_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); } inline bool Query::Builder::hasArray() { - return !_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Array::Reader -Query::Reader::getArray() const { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Array>:: - get(_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Array::Reader Query::Reader::getArray() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Array>::get(_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Array::Builder -Query::Builder::getArray() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Array>:: - get(_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Array::Builder Query::Builder::getArray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Array>::get(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Array::Pipeline -Query::Pipeline::getArray() { - return ::tiledb::sm::serialization::capnp::Array::Pipeline( - _typeless.getPointerField(6)); +inline ::tiledb::sm::serialization::capnp::Array::Pipeline Query::Pipeline::getArray() { + return ::tiledb::sm::serialization::capnp::Array::Pipeline(_typeless.getPointerField(6)); } #endif // !CAPNP_LITE -inline void Query::Builder::setArray( - ::tiledb::sm::serialization::capnp::Array::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Array>::set( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - value); +inline void Query::Builder::setArray( ::tiledb::sm::serialization::capnp::Array::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Array>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Array::Builder -Query::Builder::initArray() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Array>:: - init(_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Array::Builder Query::Builder::initArray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Array>::init(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptArray( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Array>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Array>::adopt( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Array>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Array>::adopt(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Array> -Query::Builder::disownArray() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Array>:: - disown( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Array> Query::Builder::disownArray() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Array>::disown(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); } -inline ::uint64_t Query::Reader::getTotalFixedLengthBufferBytes() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t Query::Reader::getTotalFixedLengthBufferBytes() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t Query::Builder::getTotalFixedLengthBufferBytes() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t Query::Builder::getTotalFixedLengthBufferBytes() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void Query::Builder::setTotalFixedLengthBufferBytes(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void Query::Builder::setTotalFixedLengthBufferBytes( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t Query::Reader::getTotalVarLenBufferBytes() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t Query::Reader::getTotalVarLenBufferBytes() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t Query::Builder::getTotalVarLenBufferBytes() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t Query::Builder::getTotalVarLenBufferBytes() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Query::Builder::setTotalVarLenBufferBytes(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void Query::Builder::setTotalVarLenBufferBytes( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t Query::Reader::getTotalValidityBufferBytes() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t Query::Reader::getTotalValidityBufferBytes() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t Query::Builder::getTotalValidityBufferBytes() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t Query::Builder::getTotalValidityBufferBytes() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void Query::Builder::setTotalValidityBufferBytes(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void Query::Builder::setTotalValidityBufferBytes( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool Query::Reader::hasVarOffsetsMode() const { - return !_reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); } inline bool Query::Builder::hasVarOffsetsMode() { - return !_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Query::Reader::getVarOffsetsMode() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Query::Reader::getVarOffsetsMode() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Query::Builder::getVarOffsetsMode() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Query::Builder::getVarOffsetsMode() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); } -inline void Query::Builder::setVarOffsetsMode(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - value); +inline void Query::Builder::setVarOffsetsMode( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Query::Builder::initVarOffsetsMode( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Query::Builder::initVarOffsetsMode(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), size); } inline void Query::Builder::adoptVarOffsetsMode( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Query::Builder::disownVarOffsetsMode() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Query::Builder::disownVarOffsetsMode() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); } inline bool Query::Reader::getVarOffsetsAddExtraElement() const { @@ -26329,1029 +20030,714 @@ inline void Query::Builder::setVarOffsetsAddExtraElement(bool value) { ::capnp::bounded<192>() * ::capnp::ELEMENTS, value); } -inline ::int32_t Query::Reader::getVarOffsetsBitsize() const { - return _reader.getDataField<::int32_t>( +inline ::int32_t Query::Reader::getVarOffsetsBitsize() const { + return _reader.getDataField< ::int32_t>( ::capnp::bounded<7>() * ::capnp::ELEMENTS); } -inline ::int32_t Query::Builder::getVarOffsetsBitsize() { - return _builder.getDataField<::int32_t>( +inline ::int32_t Query::Builder::getVarOffsetsBitsize() { + return _builder.getDataField< ::int32_t>( ::capnp::bounded<7>() * ::capnp::ELEMENTS); } -inline void Query::Builder::setVarOffsetsBitsize(::int32_t value) { - _builder.setDataField<::int32_t>( +inline void Query::Builder::setVarOffsetsBitsize( ::int32_t value) { + _builder.setDataField< ::int32_t>( ::capnp::bounded<7>() * ::capnp::ELEMENTS, value); } inline bool Query::Reader::hasConfig() const { - return !_reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); } inline bool Query::Builder::hasConfig() { - return !_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader -Query::Reader::getConfig() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader Query::Reader::getConfig() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -Query::Builder::getConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder Query::Builder::getConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline -Query::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline( - _typeless.getPointerField(8)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline Query::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(8)); } #endif // !CAPNP_LITE -inline void Query::Builder::setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - value); +inline void Query::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -Query::Builder::initConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder Query::Builder::initConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> -Query::Builder::disownConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> Query::Builder::disownConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasStats() const { - return !_reader.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); } inline bool Query::Builder::hasStats() { - return !_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Stats::Reader -Query::Reader::getStats() const { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - get(_reader.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Reader Query::Reader::getStats() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder -Query::Builder::getStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - get(_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder Query::Builder::getStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Stats::Pipeline -Query::Pipeline::getStats() { - return ::tiledb::sm::serialization::capnp::Stats::Pipeline( - _typeless.getPointerField(9)); +inline ::tiledb::sm::serialization::capnp::Stats::Pipeline Query::Pipeline::getStats() { + return ::tiledb::sm::serialization::capnp::Stats::Pipeline(_typeless.getPointerField(9)); } #endif // !CAPNP_LITE -inline void Query::Builder::setStats( - ::tiledb::sm::serialization::capnp::Stats::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::set( - _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), - value); +inline void Query::Builder::setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::set(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder -Query::Builder::initStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - init(_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder Query::Builder::initStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::init(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptStats( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::adopt( - _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::adopt(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> -Query::Builder::disownStats() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: - disown( - _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> Query::Builder::disownStats() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::disown(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasReaderIndex() const { - return !_reader.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); } inline bool Query::Builder::hasReaderIndex() { - return !_builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::ReaderIndex::Reader -Query::Reader::getReaderIndex() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ReaderIndex>::get( - _reader.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReaderIndex::Reader Query::Reader::getReaderIndex() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReaderIndex>::get(_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ReaderIndex::Builder -Query::Builder::getReaderIndex() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ReaderIndex>::get( - _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReaderIndex::Builder Query::Builder::getReaderIndex() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReaderIndex>::get(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ReaderIndex::Pipeline -Query::Pipeline::getReaderIndex() { - return ::tiledb::sm::serialization::capnp::ReaderIndex::Pipeline( - _typeless.getPointerField(10)); +inline ::tiledb::sm::serialization::capnp::ReaderIndex::Pipeline Query::Pipeline::getReaderIndex() { + return ::tiledb::sm::serialization::capnp::ReaderIndex::Pipeline(_typeless.getPointerField(10)); } #endif // !CAPNP_LITE -inline void Query::Builder::setReaderIndex( - ::tiledb::sm::serialization::capnp::ReaderIndex::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ReaderIndex>:: - set(_builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), - value); +inline void Query::Builder::setReaderIndex( ::tiledb::sm::serialization::capnp::ReaderIndex::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReaderIndex>::set(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::ReaderIndex::Builder -Query::Builder::initReaderIndex() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ReaderIndex>::init( - _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReaderIndex::Builder Query::Builder::initReaderIndex() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReaderIndex>::init(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptReaderIndex( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReaderIndex>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ReaderIndex>:: - adopt( - _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReaderIndex>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReaderIndex>::adopt(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReaderIndex> -Query::Builder::disownReaderIndex() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ReaderIndex>::disown( - _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReaderIndex> Query::Builder::disownReaderIndex() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReaderIndex>::disown(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasDenseReader() const { - return !_reader.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); } inline bool Query::Builder::hasDenseReader() { - return !_builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Reader -Query::Reader::getDenseReader() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::get( - _reader.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Reader Query::Reader::getDenseReader() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::get(_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Builder -Query::Builder::getDenseReader() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::get( - _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Builder Query::Builder::getDenseReader() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::get(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline -Query::Pipeline::getDenseReader() { - return ::tiledb::sm::serialization::capnp::QueryReader::Pipeline( - _typeless.getPointerField(11)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline Query::Pipeline::getDenseReader() { + return ::tiledb::sm::serialization::capnp::QueryReader::Pipeline(_typeless.getPointerField(11)); } #endif // !CAPNP_LITE -inline void Query::Builder::setDenseReader( - ::tiledb::sm::serialization::capnp::QueryReader::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>:: - set(_builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), - value); +inline void Query::Builder::setDenseReader( ::tiledb::sm::serialization::capnp::QueryReader::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::set(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Builder -Query::Builder::initDenseReader() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::init( - _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Builder Query::Builder::initDenseReader() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::init(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptDenseReader( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>:: - adopt( - _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::adopt(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader> -Query::Builder::disownDenseReader() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::disown( - _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader> Query::Builder::disownDenseReader() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::disown(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasDelete() const { - return !_reader.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); } inline bool Query::Builder::hasDelete() { - return !_builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Delete::Reader -Query::Reader::getDelete() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Delete>::get( - _reader.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Delete::Reader Query::Reader::getDelete() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Delete>::get(_reader.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Delete::Builder -Query::Builder::getDelete() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Delete>::get( - _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Delete::Builder Query::Builder::getDelete() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Delete>::get(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Delete::Pipeline -Query::Pipeline::getDelete() { - return ::tiledb::sm::serialization::capnp::Delete::Pipeline( - _typeless.getPointerField(12)); +inline ::tiledb::sm::serialization::capnp::Delete::Pipeline Query::Pipeline::getDelete() { + return ::tiledb::sm::serialization::capnp::Delete::Pipeline(_typeless.getPointerField(12)); } #endif // !CAPNP_LITE -inline void Query::Builder::setDelete( - ::tiledb::sm::serialization::capnp::Delete::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Delete>::set( - _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), - value); +inline void Query::Builder::setDelete( ::tiledb::sm::serialization::capnp::Delete::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Delete>::set(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Delete::Builder -Query::Builder::initDelete() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Delete>::init( - _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Delete::Builder Query::Builder::initDelete() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Delete>::init(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptDelete( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Delete>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Delete>::adopt( - _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Delete>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Delete>::adopt(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Delete> -Query::Builder::disownDelete() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Delete>::disown( - _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Delete> Query::Builder::disownDelete() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Delete>::disown(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasWrittenFragmentInfo() const { - return !_reader.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); } inline bool Query::Builder::hasWrittenFragmentInfo() { - return !_builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>::Reader -Query::Reader::getWrittenFragmentInfo() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<13>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>::Builder -Query::Builder::getWrittenFragmentInfo() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<13>() * - ::capnp::POINTERS)); -} -inline void Query::Builder::setWrittenFragmentInfo( - ::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>::Builder -Query::Builder::initWrittenFragmentInfo(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>::Reader Query::Reader::getWrittenFragmentInfo() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>::Builder Query::Builder::getWrittenFragmentInfo() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); +} +inline void Query::Builder::setWrittenFragmentInfo( ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>::Builder Query::Builder::initWrittenFragmentInfo(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), size); } inline void Query::Builder::adoptWrittenFragmentInfo( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>> -Query::Builder::disownWrittenFragmentInfo() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<13>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>> Query::Builder::disownWrittenFragmentInfo() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasWrittenBuffers() const { - return !_reader.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); } inline bool Query::Builder::hasWrittenBuffers() { - return !_builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -Query::Reader::getWrittenBuffers() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -Query::Builder::getWrittenBuffers() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS)); -} -inline void Query::Builder::setWrittenBuffers( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), - value); -} -inline void Query::Builder::setWrittenBuffers( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -Query::Builder::initWrittenBuffers(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader Query::Reader::getWrittenBuffers() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder Query::Builder::getWrittenBuffers() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); +} +inline void Query::Builder::setWrittenBuffers( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), value); +} +inline void Query::Builder::setWrittenBuffers(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder Query::Builder::initWrittenBuffers(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), size); } inline void Query::Builder::adoptWrittenBuffers( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -Query::Builder::disownWrittenBuffers() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> Query::Builder::disownWrittenBuffers() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasOrderedDimLabelReader() const { - return !_reader.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); } inline bool Query::Builder::hasOrderedDimLabelReader() { - return !_builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Reader -Query::Reader::getOrderedDimLabelReader() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::get( - _reader.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Reader Query::Reader::getOrderedDimLabelReader() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::get(_reader.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Builder -Query::Builder::getOrderedDimLabelReader() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::get( - _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Builder Query::Builder::getOrderedDimLabelReader() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::get(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline -Query::Pipeline::getOrderedDimLabelReader() { - return ::tiledb::sm::serialization::capnp::QueryReader::Pipeline( - _typeless.getPointerField(15)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline Query::Pipeline::getOrderedDimLabelReader() { + return ::tiledb::sm::serialization::capnp::QueryReader::Pipeline(_typeless.getPointerField(15)); } #endif // !CAPNP_LITE -inline void Query::Builder::setOrderedDimLabelReader( - ::tiledb::sm::serialization::capnp::QueryReader::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>:: - set(_builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS), - value); +inline void Query::Builder::setOrderedDimLabelReader( ::tiledb::sm::serialization::capnp::QueryReader::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::set(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Builder -Query::Builder::initOrderedDimLabelReader() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::init( - _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Builder Query::Builder::initOrderedDimLabelReader() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::init(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptOrderedDimLabelReader( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>:: - adopt( - _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::adopt(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader> -Query::Builder::disownOrderedDimLabelReader() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::disown( - _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader> Query::Builder::disownOrderedDimLabelReader() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::disown(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasChannels() const { - return !_reader.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS).isNull(); } inline bool Query::Builder::hasChannels() { - return !_builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>::Reader -Query::Reader::getChannels() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<16>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>::Builder -Query::Builder::getChannels() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<16>() * - ::capnp::POINTERS)); -} -inline void Query::Builder::setChannels( - ::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>::Builder -Query::Builder::initChannels(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>::Reader Query::Reader::getChannels() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>::Builder Query::Builder::getChannels() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS)); +} +inline void Query::Builder::setChannels( ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>::Builder Query::Builder::initChannels(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), size); } inline void Query::Builder::adoptChannels( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>> -Query::Builder::disownChannels() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::QueryChannel, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<16>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>> Query::Builder::disownChannels() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS)); } inline bool NonEmptyDomain::Reader::hasNonEmptyDomain() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool NonEmptyDomain::Builder::hasNonEmptyDomain() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Reader -NonEmptyDomain::Reader::getNonEmptyDomain() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Reader NonEmptyDomain::Reader::getNonEmptyDomain() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Builder -NonEmptyDomain::Builder::getNonEmptyDomain() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Builder NonEmptyDomain::Builder::getNonEmptyDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline -NonEmptyDomain::Pipeline::getNonEmptyDomain() { - return ::tiledb::sm::serialization::capnp::DomainArray::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline NonEmptyDomain::Pipeline::getNonEmptyDomain() { + return ::tiledb::sm::serialization::capnp::DomainArray::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void NonEmptyDomain::Builder::setNonEmptyDomain( - ::tiledb::sm::serialization::capnp::DomainArray::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void NonEmptyDomain::Builder::setNonEmptyDomain( ::tiledb::sm::serialization::capnp::DomainArray::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Builder -NonEmptyDomain::Builder::initNonEmptyDomain() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Builder NonEmptyDomain::Builder::initNonEmptyDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void NonEmptyDomain::Builder::adoptNonEmptyDomain( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray> -NonEmptyDomain::Builder::disownNonEmptyDomain() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray> NonEmptyDomain::Builder::disownNonEmptyDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool NonEmptyDomain::Reader::getIsEmpty() const { - return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool NonEmptyDomain::Builder::getIsEmpty() { - return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void NonEmptyDomain::Builder::setIsEmpty(bool value) { - _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool NonEmptyDomain::Reader::hasSizes() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool NonEmptyDomain::Builder::hasSizes() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -NonEmptyDomain::Reader::getSizes() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -NonEmptyDomain::Builder::getSizes() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void NonEmptyDomain::Builder::setSizes( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline void NonEmptyDomain::Builder::setSizes( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -NonEmptyDomain::Builder::initSizes(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader NonEmptyDomain::Reader::getSizes() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder NonEmptyDomain::Builder::getSizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void NonEmptyDomain::Builder::setSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline void NonEmptyDomain::Builder::setSizes(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder NonEmptyDomain::Builder::initSizes(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void NonEmptyDomain::Builder::adoptSizes( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -NonEmptyDomain::Builder::disownSizes() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> NonEmptyDomain::Builder::disownSizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool NonEmptyDomainList::Reader::hasNonEmptyDomains() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool NonEmptyDomainList::Builder::hasNonEmptyDomains() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>::Reader -NonEmptyDomainList::Reader::getNonEmptyDomains() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>::Builder -NonEmptyDomainList::Builder::getNonEmptyDomains() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void NonEmptyDomainList::Builder::setNonEmptyDomains( - ::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>::Builder -NonEmptyDomainList::Builder::initNonEmptyDomains(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>::Reader NonEmptyDomainList::Reader::getNonEmptyDomains() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>::Builder NonEmptyDomainList::Builder::getNonEmptyDomains() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void NonEmptyDomainList::Builder::setNonEmptyDomains( ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>::Builder NonEmptyDomainList::Builder::initNonEmptyDomains(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void NonEmptyDomainList::Builder::adoptNonEmptyDomains( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>> -NonEmptyDomainList::Builder::disownNonEmptyDomains() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::NonEmptyDomain, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>> NonEmptyDomainList::Builder::disownNonEmptyDomains() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool AttributeBufferSize::Reader::hasAttribute() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool AttributeBufferSize::Builder::hasAttribute() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader AttributeBufferSize::Reader::getAttribute() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader AttributeBufferSize::Reader::getAttribute() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder AttributeBufferSize::Builder::getAttribute() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder AttributeBufferSize::Builder::getAttribute() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void AttributeBufferSize::Builder::setAttribute( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void AttributeBufferSize::Builder::setAttribute( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder AttributeBufferSize::Builder::initAttribute( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder AttributeBufferSize::Builder::initAttribute(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void AttributeBufferSize::Builder::adoptAttribute( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -AttributeBufferSize::Builder::disownAttribute() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> AttributeBufferSize::Builder::disownAttribute() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t AttributeBufferSize::Reader::getOffsetBytes() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferSize::Reader::getOffsetBytes() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t AttributeBufferSize::Builder::getOffsetBytes() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferSize::Builder::getOffsetBytes() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void AttributeBufferSize::Builder::setOffsetBytes(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void AttributeBufferSize::Builder::setOffsetBytes( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t AttributeBufferSize::Reader::getDataBytes() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferSize::Reader::getDataBytes() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t AttributeBufferSize::Builder::getDataBytes() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferSize::Builder::getDataBytes() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void AttributeBufferSize::Builder::setDataBytes(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void AttributeBufferSize::Builder::setDataBytes( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t AttributeBufferSize::Reader::getValidityBytes() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferSize::Reader::getValidityBytes() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t AttributeBufferSize::Builder::getValidityBytes() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t AttributeBufferSize::Builder::getValidityBytes() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void AttributeBufferSize::Builder::setValidityBytes(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void AttributeBufferSize::Builder::setValidityBytes( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool ArrayMetadata::Reader::hasEntries() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ArrayMetadata::Builder::hasEntries() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>::Reader -ArrayMetadata::Reader::getEntries() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>::Builder -ArrayMetadata::Builder::getEntries() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void ArrayMetadata::Builder::setEntries( - ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>::Builder -ArrayMetadata::Builder::initEntries(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>::Reader ArrayMetadata::Reader::getEntries() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>::Builder ArrayMetadata::Builder::getEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void ArrayMetadata::Builder::setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>::Builder ArrayMetadata::Builder::initEntries(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void ArrayMetadata::Builder::adoptEntries( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>> -ArrayMetadata::Builder::disownEntries() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>> ArrayMetadata::Builder::disownEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ArrayMetadata::MetadataEntry::Reader::hasKey() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ArrayMetadata::MetadataEntry::Builder::hasKey() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::Text::Reader ArrayMetadata::MetadataEntry::Reader::getKey() - const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder ArrayMetadata::MetadataEntry::Builder::getKey() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void ArrayMetadata::MetadataEntry::Builder::setKey( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::Text::Builder ArrayMetadata::MetadataEntry::Builder::initKey( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader ArrayMetadata::MetadataEntry::Reader::getKey() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder ArrayMetadata::MetadataEntry::Builder::getKey() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void ArrayMetadata::MetadataEntry::Builder::setKey( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder ArrayMetadata::MetadataEntry::Builder::initKey(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void ArrayMetadata::MetadataEntry::Builder::adoptKey( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -ArrayMetadata::MetadataEntry::Builder::disownKey() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> ArrayMetadata::MetadataEntry::Builder::disownKey() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ArrayMetadata::MetadataEntry::Reader::hasType() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool ArrayMetadata::MetadataEntry::Builder::hasType() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::Text::Reader ArrayMetadata::MetadataEntry::Reader::getType() - const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder ArrayMetadata::MetadataEntry::Builder::getType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void ArrayMetadata::MetadataEntry::Builder::setType( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::Text::Builder ArrayMetadata::MetadataEntry::Builder::initType( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader ArrayMetadata::MetadataEntry::Reader::getType() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder ArrayMetadata::MetadataEntry::Builder::getType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void ArrayMetadata::MetadataEntry::Builder::setType( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder ArrayMetadata::MetadataEntry::Builder::initType(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void ArrayMetadata::MetadataEntry::Builder::adoptType( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -ArrayMetadata::MetadataEntry::Builder::disownType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> ArrayMetadata::MetadataEntry::Builder::disownType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::uint32_t ArrayMetadata::MetadataEntry::Reader::getValueNum() const { - return _reader.getDataField<::uint32_t>( +inline ::uint32_t ArrayMetadata::MetadataEntry::Reader::getValueNum() const { + return _reader.getDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint32_t ArrayMetadata::MetadataEntry::Builder::getValueNum() { - return _builder.getDataField<::uint32_t>( +inline ::uint32_t ArrayMetadata::MetadataEntry::Builder::getValueNum() { + return _builder.getDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ArrayMetadata::MetadataEntry::Builder::setValueNum( - ::uint32_t value) { - _builder.setDataField<::uint32_t>( +inline void ArrayMetadata::MetadataEntry::Builder::setValueNum( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool ArrayMetadata::MetadataEntry::Reader::hasValue() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool ArrayMetadata::MetadataEntry::Builder::hasValue() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::Data::Reader ArrayMetadata::MetadataEntry::Reader::getValue() - const { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::Data::Builder -ArrayMetadata::MetadataEntry::Builder::getValue() { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void ArrayMetadata::MetadataEntry::Builder::setValue( - ::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Data>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline ::capnp::Data::Builder ArrayMetadata::MetadataEntry::Builder::initValue( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Data>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Data::Reader ArrayMetadata::MetadataEntry::Reader::getValue() const { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::Data::Builder ArrayMetadata::MetadataEntry::Builder::getValue() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void ArrayMetadata::MetadataEntry::Builder::setValue( ::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::Data::Builder ArrayMetadata::MetadataEntry::Builder::initValue(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void ArrayMetadata::MetadataEntry::Builder::adoptValue( - ::capnp::Orphan<::capnp::Data>&& value) { - ::capnp::_::PointerHelpers<::capnp::Data>::adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Data>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Data> -ArrayMetadata::MetadataEntry::Builder::disownValue() { - return ::capnp::_::PointerHelpers<::capnp::Data>::disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Data> ArrayMetadata::MetadataEntry::Builder::disownValue() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool ArrayMetadata::MetadataEntry::Reader::getDel() const { - return _reader.getDataField(::capnp::bounded<32>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<32>() * ::capnp::ELEMENTS); } inline bool ArrayMetadata::MetadataEntry::Builder::getDel() { @@ -27364,1087 +20750,697 @@ inline void ArrayMetadata::MetadataEntry::Builder::setDel(bool value) { } inline bool ArrayDirectory::Reader::hasUnfilteredFragmentUris() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ArrayDirectory::Builder::hasUnfilteredFragmentUris() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -ArrayDirectory::Reader::getUnfilteredFragmentUris() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::getUnfilteredFragmentUris() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setUnfilteredFragmentUris( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline void ArrayDirectory::Builder::setUnfilteredFragmentUris( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::initUnfilteredFragmentUris(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getUnfilteredFragmentUris() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getUnfilteredFragmentUris() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setUnfilteredFragmentUris( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline void ArrayDirectory::Builder::setUnfilteredFragmentUris(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initUnfilteredFragmentUris(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void ArrayDirectory::Builder::adoptUnfilteredFragmentUris( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -ArrayDirectory::Builder::disownUnfilteredFragmentUris() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownUnfilteredFragmentUris() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasConsolidatedCommitUris() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool ArrayDirectory::Builder::hasConsolidatedCommitUris() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -ArrayDirectory::Reader::getConsolidatedCommitUris() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::getConsolidatedCommitUris() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setConsolidatedCommitUris( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline void ArrayDirectory::Builder::setConsolidatedCommitUris( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::initConsolidatedCommitUris(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getConsolidatedCommitUris() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getConsolidatedCommitUris() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setConsolidatedCommitUris( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline void ArrayDirectory::Builder::setConsolidatedCommitUris(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initConsolidatedCommitUris(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void ArrayDirectory::Builder::adoptConsolidatedCommitUris( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -ArrayDirectory::Builder::disownConsolidatedCommitUris() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownConsolidatedCommitUris() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasArraySchemaUris() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool ArrayDirectory::Builder::hasArraySchemaUris() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -ArrayDirectory::Reader::getArraySchemaUris() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::getArraySchemaUris() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setArraySchemaUris( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline void ArrayDirectory::Builder::setArraySchemaUris( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::initArraySchemaUris(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getArraySchemaUris() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getArraySchemaUris() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setArraySchemaUris( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline void ArrayDirectory::Builder::setArraySchemaUris(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initArraySchemaUris(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void ArrayDirectory::Builder::adoptArraySchemaUris( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -ArrayDirectory::Builder::disownArraySchemaUris() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownArraySchemaUris() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasLatestArraySchemaUri() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool ArrayDirectory::Builder::hasLatestArraySchemaUri() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::Text::Reader ArrayDirectory::Reader::getLatestArraySchemaUri() - const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder -ArrayDirectory::Builder::getLatestArraySchemaUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setLatestArraySchemaUri( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline ::capnp::Text::Builder ArrayDirectory::Builder::initLatestArraySchemaUri( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader ArrayDirectory::Reader::getLatestArraySchemaUri() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder ArrayDirectory::Builder::getLatestArraySchemaUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setLatestArraySchemaUri( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder ArrayDirectory::Builder::initLatestArraySchemaUri(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); } inline void ArrayDirectory::Builder::adoptLatestArraySchemaUri( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -ArrayDirectory::Builder::disownLatestArraySchemaUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> ArrayDirectory::Builder::disownLatestArraySchemaUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasArrayMetaUrisToVacuum() const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool ArrayDirectory::Builder::hasArrayMetaUrisToVacuum() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -ArrayDirectory::Reader::getArrayMetaUrisToVacuum() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::getArrayMetaUrisToVacuum() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setArrayMetaUrisToVacuum( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); -} -inline void ArrayDirectory::Builder::setArrayMetaUrisToVacuum( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::initArrayMetaUrisToVacuum(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getArrayMetaUrisToVacuum() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getArrayMetaUrisToVacuum() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setArrayMetaUrisToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline void ArrayDirectory::Builder::setArrayMetaUrisToVacuum(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initArrayMetaUrisToVacuum(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); } inline void ArrayDirectory::Builder::adoptArrayMetaUrisToVacuum( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -ArrayDirectory::Builder::disownArrayMetaUrisToVacuum() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownArrayMetaUrisToVacuum() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasArrayMetaVacUrisToVacuum() const { - return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } inline bool ArrayDirectory::Builder::hasArrayMetaVacUrisToVacuum() { - return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -ArrayDirectory::Reader::getArrayMetaVacUrisToVacuum() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::getArrayMetaVacUrisToVacuum() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setArrayMetaVacUrisToVacuum( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - value); -} -inline void ArrayDirectory::Builder::setArrayMetaVacUrisToVacuum( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::initArrayMetaVacUrisToVacuum(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getArrayMetaVacUrisToVacuum() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getArrayMetaVacUrisToVacuum() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setArrayMetaVacUrisToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline void ArrayDirectory::Builder::setArrayMetaVacUrisToVacuum(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initArrayMetaVacUrisToVacuum(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), size); } inline void ArrayDirectory::Builder::adoptArrayMetaVacUrisToVacuum( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -ArrayDirectory::Builder::disownArrayMetaVacUrisToVacuum() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownArrayMetaVacUrisToVacuum() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasCommitUrisToConsolidate() const { - return !_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); } inline bool ArrayDirectory::Builder::hasCommitUrisToConsolidate() { - return !_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -ArrayDirectory::Reader::getCommitUrisToConsolidate() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::getCommitUrisToConsolidate() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setCommitUrisToConsolidate( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - value); -} -inline void ArrayDirectory::Builder::setCommitUrisToConsolidate( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::initCommitUrisToConsolidate(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getCommitUrisToConsolidate() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getCommitUrisToConsolidate() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setCommitUrisToConsolidate( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline void ArrayDirectory::Builder::setCommitUrisToConsolidate(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initCommitUrisToConsolidate(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), size); } inline void ArrayDirectory::Builder::adoptCommitUrisToConsolidate( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -ArrayDirectory::Builder::disownCommitUrisToConsolidate() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownCommitUrisToConsolidate() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasCommitUrisToVacuum() const { - return !_reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); } inline bool ArrayDirectory::Builder::hasCommitUrisToVacuum() { - return !_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -ArrayDirectory::Reader::getCommitUrisToVacuum() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::getCommitUrisToVacuum() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setCommitUrisToVacuum( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - value); -} -inline void ArrayDirectory::Builder::setCommitUrisToVacuum( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::initCommitUrisToVacuum(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getCommitUrisToVacuum() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getCommitUrisToVacuum() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setCommitUrisToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline void ArrayDirectory::Builder::setCommitUrisToVacuum(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initCommitUrisToVacuum(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), size); } inline void ArrayDirectory::Builder::adoptCommitUrisToVacuum( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -ArrayDirectory::Builder::disownCommitUrisToVacuum() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownCommitUrisToVacuum() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasConsolidatedCommitUrisToVacuum() const { - return !_reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); } inline bool ArrayDirectory::Builder::hasConsolidatedCommitUrisToVacuum() { - return !_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -ArrayDirectory::Reader::getConsolidatedCommitUrisToVacuum() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::getConsolidatedCommitUrisToVacuum() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setConsolidatedCommitUrisToVacuum( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - value); -} -inline void ArrayDirectory::Builder::setConsolidatedCommitUrisToVacuum( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::initConsolidatedCommitUrisToVacuum(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getConsolidatedCommitUrisToVacuum() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getConsolidatedCommitUrisToVacuum() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setConsolidatedCommitUrisToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline void ArrayDirectory::Builder::setConsolidatedCommitUrisToVacuum(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initConsolidatedCommitUrisToVacuum(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), size); } inline void ArrayDirectory::Builder::adoptConsolidatedCommitUrisToVacuum( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -ArrayDirectory::Builder::disownConsolidatedCommitUrisToVacuum() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownConsolidatedCommitUrisToVacuum() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasArrayMetaUris() const { - return !_reader.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); } inline bool ArrayDirectory::Builder::hasArrayMetaUris() { - return !_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>::Reader -ArrayDirectory::Reader::getArrayMetaUris() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<9>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>::Builder -ArrayDirectory::Builder::getArrayMetaUris() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<9>() * - ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setArrayMetaUris( - ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>::Builder -ArrayDirectory::Builder::initArrayMetaUris(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>::Reader ArrayDirectory::Reader::getArrayMetaUris() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>::Builder ArrayDirectory::Builder::getArrayMetaUris() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setArrayMetaUris( ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>::Builder ArrayDirectory::Builder::initArrayMetaUris(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), size); } inline void ArrayDirectory::Builder::adoptArrayMetaUris( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>> -ArrayDirectory::Builder::disownArrayMetaUris() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<9>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>> ArrayDirectory::Builder::disownArrayMetaUris() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasFragmentMetaUris() const { - return !_reader.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); } inline bool ArrayDirectory::Builder::hasFragmentMetaUris() { - return !_builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -ArrayDirectory::Reader::getFragmentMetaUris() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::getFragmentMetaUris() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setFragmentMetaUris( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), - value); -} -inline void ArrayDirectory::Builder::setFragmentMetaUris( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDirectory::Builder::initFragmentMetaUris(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getFragmentMetaUris() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getFragmentMetaUris() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setFragmentMetaUris( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), value); +} +inline void ArrayDirectory::Builder::setFragmentMetaUris(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initFragmentMetaUris(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), size); } inline void ArrayDirectory::Builder::adoptFragmentMetaUris( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -ArrayDirectory::Builder::disownFragmentMetaUris() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownFragmentMetaUris() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasDeleteAndUpdateTileLocation() const { - return !_reader.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); } inline bool ArrayDirectory::Builder::hasDeleteAndUpdateTileLocation() { - return !_builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>::Reader -ArrayDirectory::Reader::getDeleteAndUpdateTileLocation() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<11>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>::Builder -ArrayDirectory::Builder::getDeleteAndUpdateTileLocation() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<11>() * - ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setDeleteAndUpdateTileLocation( - ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>::Builder -ArrayDirectory::Builder::initDeleteAndUpdateTileLocation(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>::Reader ArrayDirectory::Reader::getDeleteAndUpdateTileLocation() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>::Builder ArrayDirectory::Builder::getDeleteAndUpdateTileLocation() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setDeleteAndUpdateTileLocation( ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>::Builder ArrayDirectory::Builder::initDeleteAndUpdateTileLocation(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), size); } inline void ArrayDirectory::Builder::adoptDeleteAndUpdateTileLocation( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>> -ArrayDirectory::Builder::disownDeleteAndUpdateTileLocation() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ArrayDirectory:: - DeleteAndUpdateTileLocation, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<11>() * - ::capnp::POINTERS)); -} - -inline ::uint64_t ArrayDirectory::Reader::getTimestampStart() const { - return _reader.getDataField<::uint64_t>( + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>> ArrayDirectory::Builder::disownDeleteAndUpdateTileLocation() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} + +inline ::uint64_t ArrayDirectory::Reader::getTimestampStart() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t ArrayDirectory::Builder::getTimestampStart() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t ArrayDirectory::Builder::getTimestampStart() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ArrayDirectory::Builder::setTimestampStart(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void ArrayDirectory::Builder::setTimestampStart( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t ArrayDirectory::Reader::getTimestampEnd() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t ArrayDirectory::Reader::getTimestampEnd() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t ArrayDirectory::Builder::getTimestampEnd() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t ArrayDirectory::Builder::getTimestampEnd() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void ArrayDirectory::Builder::setTimestampEnd(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void ArrayDirectory::Builder::setTimestampEnd( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool ArrayDirectory::TimestampedURI::Reader::hasUri() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ArrayDirectory::TimestampedURI::Builder::hasUri() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::Text::Reader ArrayDirectory::TimestampedURI::Reader::getUri() - const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder -ArrayDirectory::TimestampedURI::Builder::getUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::TimestampedURI::Builder::setUri( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::Text::Builder ArrayDirectory::TimestampedURI::Builder::initUri( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader ArrayDirectory::TimestampedURI::Reader::getUri() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder ArrayDirectory::TimestampedURI::Builder::getUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::TimestampedURI::Builder::setUri( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder ArrayDirectory::TimestampedURI::Builder::initUri(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void ArrayDirectory::TimestampedURI::Builder::adoptUri( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -ArrayDirectory::TimestampedURI::Builder::disownUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> ArrayDirectory::TimestampedURI::Builder::disownUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t ArrayDirectory::TimestampedURI::Reader::getTimestampStart() - const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t ArrayDirectory::TimestampedURI::Reader::getTimestampStart() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t ArrayDirectory::TimestampedURI::Builder::getTimestampStart() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t ArrayDirectory::TimestampedURI::Builder::getTimestampStart() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ArrayDirectory::TimestampedURI::Builder::setTimestampStart( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void ArrayDirectory::TimestampedURI::Builder::setTimestampStart( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t ArrayDirectory::TimestampedURI::Reader::getTimestampEnd() - const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t ArrayDirectory::TimestampedURI::Reader::getTimestampEnd() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t ArrayDirectory::TimestampedURI::Builder::getTimestampEnd() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t ArrayDirectory::TimestampedURI::Builder::getTimestampEnd() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void ArrayDirectory::TimestampedURI::Builder::setTimestampEnd( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void ArrayDirectory::TimestampedURI::Builder::setTimestampEnd( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline bool ArrayDirectory::DeleteAndUpdateTileLocation::Reader::hasUri() - const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); +inline bool ArrayDirectory::DeleteAndUpdateTileLocation::Reader::hasUri() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ArrayDirectory::DeleteAndUpdateTileLocation::Builder::hasUri() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::Text::Reader -ArrayDirectory::DeleteAndUpdateTileLocation::Reader::getUri() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder -ArrayDirectory::DeleteAndUpdateTileLocation::Builder::getUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::DeleteAndUpdateTileLocation::Builder::setUri( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::Text::Builder -ArrayDirectory::DeleteAndUpdateTileLocation::Builder::initUri( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader ArrayDirectory::DeleteAndUpdateTileLocation::Reader::getUri() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder ArrayDirectory::DeleteAndUpdateTileLocation::Builder::getUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::DeleteAndUpdateTileLocation::Builder::setUri( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder ArrayDirectory::DeleteAndUpdateTileLocation::Builder::initUri(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void ArrayDirectory::DeleteAndUpdateTileLocation::Builder::adoptUri( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::Text> -ArrayDirectory::DeleteAndUpdateTileLocation::Builder::disownUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} - -inline bool -ArrayDirectory::DeleteAndUpdateTileLocation::Reader::hasConditionMarker() - const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline bool -ArrayDirectory::DeleteAndUpdateTileLocation::Builder::hasConditionMarker() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::Text::Reader -ArrayDirectory::DeleteAndUpdateTileLocation::Reader::getConditionMarker() - const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder -ArrayDirectory::DeleteAndUpdateTileLocation::Builder::getConditionMarker() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void -ArrayDirectory::DeleteAndUpdateTileLocation::Builder::setConditionMarker( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::Text::Builder -ArrayDirectory::DeleteAndUpdateTileLocation::Builder::initConditionMarker( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); -} -inline void -ArrayDirectory::DeleteAndUpdateTileLocation::Builder::adoptConditionMarker( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::Text> -ArrayDirectory::DeleteAndUpdateTileLocation::Builder::disownConditionMarker() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} - -inline ::uint64_t -ArrayDirectory::DeleteAndUpdateTileLocation::Reader::getOffset() const { - return _reader.getDataField<::uint64_t>( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> ArrayDirectory::DeleteAndUpdateTileLocation::Builder::disownUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool ArrayDirectory::DeleteAndUpdateTileLocation::Reader::hasConditionMarker() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline bool ArrayDirectory::DeleteAndUpdateTileLocation::Builder::hasConditionMarker() { + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader ArrayDirectory::DeleteAndUpdateTileLocation::Reader::getConditionMarker() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder ArrayDirectory::DeleteAndUpdateTileLocation::Builder::getConditionMarker() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::DeleteAndUpdateTileLocation::Builder::setConditionMarker( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder ArrayDirectory::DeleteAndUpdateTileLocation::Builder::initConditionMarker(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); +} +inline void ArrayDirectory::DeleteAndUpdateTileLocation::Builder::adoptConditionMarker( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> ArrayDirectory::DeleteAndUpdateTileLocation::Builder::disownConditionMarker() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline ::uint64_t ArrayDirectory::DeleteAndUpdateTileLocation::Reader::getOffset() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t -ArrayDirectory::DeleteAndUpdateTileLocation::Builder::getOffset() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t ArrayDirectory::DeleteAndUpdateTileLocation::Builder::getOffset() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ArrayDirectory::DeleteAndUpdateTileLocation::Builder::setOffset( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void ArrayDirectory::DeleteAndUpdateTileLocation::Builder::setOffset( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool EstimatedResultSize::Reader::hasResultSizes() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool EstimatedResultSize::Builder::hasResultSizes() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Reader -EstimatedResultSize::Reader::getResultSizes() const { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>:: - get(_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: - Builder - EstimatedResultSize::Builder::getResultSizes() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>:: - get(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: - Pipeline - EstimatedResultSize::Pipeline::getResultSizes() { - return ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: - Pipeline(_typeless.getPointerField(0)); -} -#endif // !CAPNP_LITE -inline void EstimatedResultSize::Builder::setResultSizes( - ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: - Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: - Builder - EstimatedResultSize::Builder::initResultSizes() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>:: - init(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Reader EstimatedResultSize::Reader::getResultSizes() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Builder EstimatedResultSize::Builder::getResultSizes() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Pipeline EstimatedResultSize::Pipeline::getResultSizes() { + return ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Pipeline(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +inline void EstimatedResultSize::Builder::setResultSizes( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Builder EstimatedResultSize::Builder::initResultSizes() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void EstimatedResultSize::Builder::adoptResultSizes( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>&& - value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>> -EstimatedResultSize::Builder::disownResultSizes() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>:: - disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>> EstimatedResultSize::Builder::disownResultSizes() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool EstimatedResultSize::Reader::hasMemorySizes() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool EstimatedResultSize::Builder::hasMemorySizes() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Reader -EstimatedResultSize::Reader::getMemorySizes() const { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>:: - get(_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: - Builder - EstimatedResultSize::Builder::getMemorySizes() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>:: - get(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: - Pipeline - EstimatedResultSize::Pipeline::getMemorySizes() { - return ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: - Pipeline(_typeless.getPointerField(1)); -} -#endif // !CAPNP_LITE -inline void EstimatedResultSize::Builder::setMemorySizes( - ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: - Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>:: - set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: - Builder - EstimatedResultSize::Builder::initMemorySizes() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>:: - init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Reader EstimatedResultSize::Reader::getMemorySizes() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Builder EstimatedResultSize::Builder::getMemorySizes() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Pipeline EstimatedResultSize::Pipeline::getMemorySizes() { + return ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void EstimatedResultSize::Builder::setMemorySizes( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Builder EstimatedResultSize::Builder::initMemorySizes() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void EstimatedResultSize::Builder::adoptMemorySizes( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>&& - value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>> -EstimatedResultSize::Builder::disownMemorySizes() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>> EstimatedResultSize::Builder::disownMemorySizes() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline double EstimatedResultSize::ResultSize::Reader::getSizeFixed() const { @@ -28456,8 +21452,7 @@ inline double EstimatedResultSize::ResultSize::Builder::getSizeFixed() { return _builder.getDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void EstimatedResultSize::ResultSize::Builder::setSizeFixed( - double value) { +inline void EstimatedResultSize::ResultSize::Builder::setSizeFixed(double value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } @@ -28485,6010 +21480,3939 @@ inline double EstimatedResultSize::ResultSize::Builder::getSizeValidity() { return _builder.getDataField( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void EstimatedResultSize::ResultSize::Builder::setSizeValidity( - double value) { +inline void EstimatedResultSize::ResultSize::Builder::setSizeValidity(double value) { _builder.setDataField( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t EstimatedResultSize::MemorySize::Reader::getSizeFixed() - const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t EstimatedResultSize::MemorySize::Reader::getSizeFixed() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t EstimatedResultSize::MemorySize::Builder::getSizeFixed() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t EstimatedResultSize::MemorySize::Builder::getSizeFixed() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void EstimatedResultSize::MemorySize::Builder::setSizeFixed( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void EstimatedResultSize::MemorySize::Builder::setSizeFixed( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t EstimatedResultSize::MemorySize::Reader::getSizeVar() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t EstimatedResultSize::MemorySize::Reader::getSizeVar() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t EstimatedResultSize::MemorySize::Builder::getSizeVar() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t EstimatedResultSize::MemorySize::Builder::getSizeVar() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void EstimatedResultSize::MemorySize::Builder::setSizeVar( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void EstimatedResultSize::MemorySize::Builder::setSizeVar( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t EstimatedResultSize::MemorySize::Reader::getSizeValidity() - const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t EstimatedResultSize::MemorySize::Reader::getSizeValidity() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t EstimatedResultSize::MemorySize::Builder::getSizeValidity() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t EstimatedResultSize::MemorySize::Builder::getSizeValidity() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void EstimatedResultSize::MemorySize::Builder::setSizeValidity( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void EstimatedResultSize::MemorySize::Builder::setSizeValidity( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool FragmentInfoRequest::Reader::hasConfig() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool FragmentInfoRequest::Builder::hasConfig() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader -FragmentInfoRequest::Reader::getConfig() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader FragmentInfoRequest::Reader::getConfig() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -FragmentInfoRequest::Builder::getConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder FragmentInfoRequest::Builder::getConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline -FragmentInfoRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline FragmentInfoRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void FragmentInfoRequest::Builder::setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void FragmentInfoRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -FragmentInfoRequest::Builder::initConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder FragmentInfoRequest::Builder::initConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void FragmentInfoRequest::Builder::adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> -FragmentInfoRequest::Builder::disownConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> FragmentInfoRequest::Builder::disownConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool SingleFragmentInfo::Reader::hasArraySchemaName() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool SingleFragmentInfo::Builder::hasArraySchemaName() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::Text::Reader SingleFragmentInfo::Reader::getArraySchemaName() - const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder -SingleFragmentInfo::Builder::getArraySchemaName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void SingleFragmentInfo::Builder::setArraySchemaName( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::Text::Builder SingleFragmentInfo::Builder::initArraySchemaName( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader SingleFragmentInfo::Reader::getArraySchemaName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder SingleFragmentInfo::Builder::getArraySchemaName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void SingleFragmentInfo::Builder::setArraySchemaName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder SingleFragmentInfo::Builder::initArraySchemaName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void SingleFragmentInfo::Builder::adoptArraySchemaName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -SingleFragmentInfo::Builder::disownArraySchemaName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> SingleFragmentInfo::Builder::disownArraySchemaName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool SingleFragmentInfo::Reader::hasMeta() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool SingleFragmentInfo::Builder::hasMeta() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader -SingleFragmentInfo::Reader::getMeta() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader SingleFragmentInfo::Reader::getMeta() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder -SingleFragmentInfo::Builder::getMeta() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder SingleFragmentInfo::Builder::getMeta() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline -SingleFragmentInfo::Pipeline::getMeta() { - return ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline( - _typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline SingleFragmentInfo::Pipeline::getMeta() { + return ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline(_typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void SingleFragmentInfo::Builder::setMeta( - ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void SingleFragmentInfo::Builder::setMeta( ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder -SingleFragmentInfo::Builder::initMeta() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::FragmentMetadata>:: - init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder SingleFragmentInfo::Builder::initMeta() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void SingleFragmentInfo::Builder::adoptMeta( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata>&& - value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::FragmentMetadata>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata> -SingleFragmentInfo::Builder::disownMeta() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::FragmentMetadata>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} - -inline ::uint64_t SingleFragmentInfo::Reader::getFragmentSize() const { - return _reader.getDataField<::uint64_t>( + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata> SingleFragmentInfo::Builder::disownMeta() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline ::uint64_t SingleFragmentInfo::Reader::getFragmentSize() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t SingleFragmentInfo::Builder::getFragmentSize() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t SingleFragmentInfo::Builder::getFragmentSize() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void SingleFragmentInfo::Builder::setFragmentSize(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void SingleFragmentInfo::Builder::setFragmentSize( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool FragmentInfo::Reader::hasArraySchemaLatest() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool FragmentInfo::Builder::hasArraySchemaLatest() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader -FragmentInfo::Reader::getArraySchemaLatest() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader FragmentInfo::Reader::getArraySchemaLatest() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder -FragmentInfo::Builder::getArraySchemaLatest() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder FragmentInfo::Builder::getArraySchemaLatest() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline -FragmentInfo::Pipeline::getArraySchemaLatest() { - return ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline FragmentInfo::Pipeline::getArraySchemaLatest() { + return ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void FragmentInfo::Builder::setArraySchemaLatest( - ::tiledb::sm::serialization::capnp::ArraySchema::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void FragmentInfo::Builder::setArraySchemaLatest( ::tiledb::sm::serialization::capnp::ArraySchema::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder -FragmentInfo::Builder::initArraySchemaLatest() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder FragmentInfo::Builder::initArraySchemaLatest() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void FragmentInfo::Builder::adoptArraySchemaLatest( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema> -FragmentInfo::Builder::disownArraySchemaLatest() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema> FragmentInfo::Builder::disownArraySchemaLatest() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool FragmentInfo::Reader::hasArraySchemasAll() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool FragmentInfo::Builder::hasArraySchemasAll() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::tiledb::sm::serialization::capnp:: - Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader - FragmentInfo::Reader::getArraySchemasAll() const { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - get(_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp:: - Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder - FragmentInfo::Builder::getArraySchemasAll() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - get(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline -FragmentInfo::Pipeline::getArraySchemasAll() { - return ::tiledb::sm::serialization::capnp:: - Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>:: - Pipeline(_typeless.getPointerField(1)); -} -#endif // !CAPNP_LITE -inline void FragmentInfo::Builder::setArraySchemasAll( - ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::tiledb::sm::serialization::capnp:: - Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder - FragmentInfo::Builder::initArraySchemasAll() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader FragmentInfo::Reader::getArraySchemasAll() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder FragmentInfo::Builder::getArraySchemasAll() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline FragmentInfo::Pipeline::getArraySchemasAll() { + return ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void FragmentInfo::Builder::setArraySchemasAll( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder FragmentInfo::Builder::initArraySchemasAll() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void FragmentInfo::Builder::adoptArraySchemasAll( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>> -FragmentInfo::Builder::disownArraySchemasAll() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>> FragmentInfo::Builder::disownArraySchemasAll() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool FragmentInfo::Reader::hasFragmentInfo() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool FragmentInfo::Builder::hasFragmentInfo() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>::Reader -FragmentInfo::Reader::getFragmentInfo() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<2>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>::Builder -FragmentInfo::Builder::getFragmentInfo() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<2>() * - ::capnp::POINTERS)); -} -inline void FragmentInfo::Builder::setFragmentInfo( - ::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>::Builder -FragmentInfo::Builder::initFragmentInfo(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>::Reader FragmentInfo::Reader::getFragmentInfo() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>::Builder FragmentInfo::Builder::getFragmentInfo() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void FragmentInfo::Builder::setFragmentInfo( ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>::Builder FragmentInfo::Builder::initFragmentInfo(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void FragmentInfo::Builder::adoptFragmentInfo( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>> -FragmentInfo::Builder::disownFragmentInfo() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SingleFragmentInfo, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<2>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>> FragmentInfo::Builder::disownFragmentInfo() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool FragmentInfo::Reader::hasToVacuum() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool FragmentInfo::Builder::hasToVacuum() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -FragmentInfo::Reader::getToVacuum() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -FragmentInfo::Builder::getToVacuum() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline void FragmentInfo::Builder::setToVacuum( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline void FragmentInfo::Builder::setToVacuum( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -FragmentInfo::Builder::initToVacuum(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader FragmentInfo::Reader::getToVacuum() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder FragmentInfo::Builder::getToVacuum() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void FragmentInfo::Builder::setToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline void FragmentInfo::Builder::setToVacuum(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder FragmentInfo::Builder::initToVacuum(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); } inline void FragmentInfo::Builder::adoptToVacuum( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -FragmentInfo::Builder::disownToVacuum() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> FragmentInfo::Builder::disownToVacuum() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool GroupMetadata::Reader::hasConfig() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool GroupMetadata::Builder::hasConfig() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader -GroupMetadata::Reader::getConfig() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader GroupMetadata::Reader::getConfig() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -GroupMetadata::Builder::getConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder GroupMetadata::Builder::getConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline -GroupMetadata::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline GroupMetadata::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void GroupMetadata::Builder::setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void GroupMetadata::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -GroupMetadata::Builder::initConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder GroupMetadata::Builder::initConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void GroupMetadata::Builder::adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> -GroupMetadata::Builder::disownConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> GroupMetadata::Builder::disownConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool GroupMetadata::Reader::hasMetadata() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool GroupMetadata::Builder::hasMetadata() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader -GroupMetadata::Reader::getMetadata() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader GroupMetadata::Reader::getMetadata() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder -GroupMetadata::Builder::getMetadata() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder GroupMetadata::Builder::getMetadata() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline -GroupMetadata::Pipeline::getMetadata() { - return ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline( - _typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline GroupMetadata::Pipeline::getMetadata() { + return ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline(_typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void GroupMetadata::Builder::setMetadata( - ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void GroupMetadata::Builder::setMetadata( ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder -GroupMetadata::Builder::initMetadata() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder GroupMetadata::Builder::initMetadata() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void GroupMetadata::Builder::adoptMetadata( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata>&& - value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata> -GroupMetadata::Builder::disownMetadata() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata> GroupMetadata::Builder::disownMetadata() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool GroupMember::Reader::hasUri() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool GroupMember::Builder::hasUri() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader GroupMember::Reader::getUri() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader GroupMember::Reader::getUri() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder GroupMember::Builder::getUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder GroupMember::Builder::getUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void GroupMember::Builder::setUri(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void GroupMember::Builder::setUri( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder GroupMember::Builder::initUri(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder GroupMember::Builder::initUri(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void GroupMember::Builder::adoptUri( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> GroupMember::Builder::disownUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> GroupMember::Builder::disownUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool GroupMember::Reader::hasType() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool GroupMember::Builder::hasType() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader GroupMember::Reader::getType() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader GroupMember::Reader::getType() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder GroupMember::Builder::getType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder GroupMember::Builder::getType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void GroupMember::Builder::setType(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void GroupMember::Builder::setType( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder GroupMember::Builder::initType( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder GroupMember::Builder::initType(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void GroupMember::Builder::adoptType( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> GroupMember::Builder::disownType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> GroupMember::Builder::disownType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool GroupMember::Reader::getRelative() const { - return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool GroupMember::Builder::getRelative() { - return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void GroupMember::Builder::setRelative(bool value) { - _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool GroupMember::Reader::hasName() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool GroupMember::Builder::hasName() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader GroupMember::Reader::getName() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader GroupMember::Reader::getName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder GroupMember::Builder::getName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder GroupMember::Builder::getName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void GroupMember::Builder::setName(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void GroupMember::Builder::setName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder GroupMember::Builder::initName( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder GroupMember::Builder::initName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void GroupMember::Builder::adoptName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> GroupMember::Builder::disownName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> GroupMember::Builder::disownName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Group::Reader::hasConfig() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool Group::Builder::hasConfig() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader -Group::Reader::getConfig() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader Group::Reader::getConfig() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -Group::Builder::getConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder Group::Builder::getConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline -Group::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline Group::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void Group::Builder::setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void Group::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -Group::Builder::initConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder Group::Builder::initConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void Group::Builder::adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> -Group::Builder::disownConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> Group::Builder::disownConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Group::Reader::hasGroup() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool Group::Builder::hasGroup() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Reader -Group::Reader::getGroup() const { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::Group::GroupDetails>:: - get(_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Reader Group::Reader::getGroup() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Group::GroupDetails>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Builder -Group::Builder::getGroup() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::Group::GroupDetails>:: - get(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Builder Group::Builder::getGroup() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Group::GroupDetails>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Pipeline -Group::Pipeline::getGroup() { - return ::tiledb::sm::serialization::capnp::Group::GroupDetails::Pipeline( - _typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Pipeline Group::Pipeline::getGroup() { + return ::tiledb::sm::serialization::capnp::Group::GroupDetails::Pipeline(_typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void Group::Builder::setGroup( - ::tiledb::sm::serialization::capnp::Group::GroupDetails::Reader value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::Group::GroupDetails>:: - set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void Group::Builder::setGroup( ::tiledb::sm::serialization::capnp::Group::GroupDetails::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Group::GroupDetails>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Builder -Group::Builder::initGroup() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::Group::GroupDetails>:: - init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Builder Group::Builder::initGroup() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Group::GroupDetails>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void Group::Builder::adoptGroup( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Group::GroupDetails>&& - value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::Group::GroupDetails>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Group::GroupDetails> -Group::Builder::disownGroup() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::Group::GroupDetails>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Group::GroupDetails>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Group::GroupDetails>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Group::GroupDetails> Group::Builder::disownGroup() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Group::GroupDetails>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Group::GroupDetails::Reader::hasMembers() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool Group::GroupDetails::Builder::hasMembers() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>::Reader -Group::GroupDetails::Reader::getMembers() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>::Builder -Group::GroupDetails::Builder::getMembers() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void Group::GroupDetails::Builder::setMembers( - ::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>::Builder -Group::GroupDetails::Builder::initMembers(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Reader Group::GroupDetails::Reader::getMembers() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Builder Group::GroupDetails::Builder::getMembers() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void Group::GroupDetails::Builder::setMembers( ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Builder Group::GroupDetails::Builder::initMembers(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void Group::GroupDetails::Builder::adoptMembers( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>> -Group::GroupDetails::Builder::disownMembers() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>> Group::GroupDetails::Builder::disownMembers() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Group::GroupDetails::Reader::hasMetadata() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool Group::GroupDetails::Builder::hasMetadata() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader -Group::GroupDetails::Reader::getMetadata() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader Group::GroupDetails::Reader::getMetadata() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder -Group::GroupDetails::Builder::getMetadata() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder Group::GroupDetails::Builder::getMetadata() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline -Group::GroupDetails::Pipeline::getMetadata() { - return ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline( - _typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline Group::GroupDetails::Pipeline::getMetadata() { + return ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline(_typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void Group::GroupDetails::Builder::setMetadata( - ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void Group::GroupDetails::Builder::setMetadata( ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder -Group::GroupDetails::Builder::initMetadata() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder Group::GroupDetails::Builder::initMetadata() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void Group::GroupDetails::Builder::adoptMetadata( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata>&& - value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata> -Group::GroupDetails::Builder::disownMetadata() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata> Group::GroupDetails::Builder::disownMetadata() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool GroupUpdate::Reader::hasConfig() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool GroupUpdate::Builder::hasConfig() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader -GroupUpdate::Reader::getConfig() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader GroupUpdate::Reader::getConfig() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -GroupUpdate::Builder::getConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder GroupUpdate::Builder::getConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline -GroupUpdate::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline GroupUpdate::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void GroupUpdate::Builder::setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void GroupUpdate::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -GroupUpdate::Builder::initConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder GroupUpdate::Builder::initConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void GroupUpdate::Builder::adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> -GroupUpdate::Builder::disownConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> GroupUpdate::Builder::disownConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool GroupUpdate::Reader::hasGroupUpdate() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool GroupUpdate::Builder::hasGroupUpdate() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: - Reader - GroupUpdate::Reader::getGroupUpdate() const { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>:: - get(_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: - Builder - GroupUpdate::Builder::getGroupUpdate() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>:: - get(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: - Pipeline - GroupUpdate::Pipeline::getGroupUpdate() { - return ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: - Pipeline(_typeless.getPointerField(1)); -} -#endif // !CAPNP_LITE -inline void GroupUpdate::Builder::setGroupUpdate( - ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Reader - value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>:: - set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: - Builder - GroupUpdate::Builder::initGroupUpdate() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>:: - init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Reader GroupUpdate::Reader::getGroupUpdate() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Builder GroupUpdate::Builder::getGroupUpdate() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Pipeline GroupUpdate::Pipeline::getGroupUpdate() { + return ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void GroupUpdate::Builder::setGroupUpdate( ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Builder GroupUpdate::Builder::initGroupUpdate() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void GroupUpdate::Builder::adoptGroupUpdate( - ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>&& - value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails> -GroupUpdate::Builder::disownGroupUpdate() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} - -inline bool GroupUpdate::GroupUpdateDetails::Reader::hasMembersToRemove() - const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails> GroupUpdate::Builder::disownGroupUpdate() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool GroupUpdate::GroupUpdateDetails::Reader::hasMembersToRemove() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool GroupUpdate::GroupUpdateDetails::Builder::hasMembersToRemove() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -GroupUpdate::GroupUpdateDetails::Reader::getMembersToRemove() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -GroupUpdate::GroupUpdateDetails::Builder::getMembersToRemove() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void GroupUpdate::GroupUpdateDetails::Builder::setMembersToRemove( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline void GroupUpdate::GroupUpdateDetails::Builder::setMembersToRemove( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -GroupUpdate::GroupUpdateDetails::Builder::initMembersToRemove( - unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader GroupUpdate::GroupUpdateDetails::Reader::getMembersToRemove() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder GroupUpdate::GroupUpdateDetails::Builder::getMembersToRemove() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void GroupUpdate::GroupUpdateDetails::Builder::setMembersToRemove( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline void GroupUpdate::GroupUpdateDetails::Builder::setMembersToRemove(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder GroupUpdate::GroupUpdateDetails::Builder::initMembersToRemove(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void GroupUpdate::GroupUpdateDetails::Builder::adoptMembersToRemove( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -GroupUpdate::GroupUpdateDetails::Builder::disownMembersToRemove() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> GroupUpdate::GroupUpdateDetails::Builder::disownMembersToRemove() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool GroupUpdate::GroupUpdateDetails::Reader::hasMembersToAdd() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool GroupUpdate::GroupUpdateDetails::Builder::hasMembersToAdd() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>::Reader -GroupUpdate::GroupUpdateDetails::Reader::getMembersToAdd() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>::Builder -GroupUpdate::GroupUpdateDetails::Builder::getMembersToAdd() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); -} -inline void GroupUpdate::GroupUpdateDetails::Builder::setMembersToAdd( - ::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>::Builder -GroupUpdate::GroupUpdateDetails::Builder::initMembersToAdd(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Reader GroupUpdate::GroupUpdateDetails::Reader::getMembersToAdd() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Builder GroupUpdate::GroupUpdateDetails::Builder::getMembersToAdd() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void GroupUpdate::GroupUpdateDetails::Builder::setMembersToAdd( ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Builder GroupUpdate::GroupUpdateDetails::Builder::initMembersToAdd(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void GroupUpdate::GroupUpdateDetails::Builder::adoptMembersToAdd( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>> -GroupUpdate::GroupUpdateDetails::Builder::disownMembersToAdd() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::GroupMember, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<1>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>> GroupUpdate::GroupUpdateDetails::Builder::disownMembersToAdd() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool GroupCreate::Reader::hasConfig() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool GroupCreate::Builder::hasConfig() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader -GroupCreate::Reader::getConfig() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader GroupCreate::Reader::getConfig() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -GroupCreate::Builder::getConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder GroupCreate::Builder::getConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline -GroupCreate::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline GroupCreate::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void GroupCreate::Builder::setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void GroupCreate::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -GroupCreate::Builder::initConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder GroupCreate::Builder::initConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void GroupCreate::Builder::adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> -GroupCreate::Builder::disownConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> GroupCreate::Builder::disownConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool GroupCreate::Reader::hasGroupDetails() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool GroupCreate::Builder::hasGroupDetails() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: - Reader - GroupCreate::Reader::getGroupDetails() const { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>:: - get(_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: - Builder - GroupCreate::Builder::getGroupDetails() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>:: - get(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: - Pipeline - GroupCreate::Pipeline::getGroupDetails() { - return ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: - Pipeline(_typeless.getPointerField(1)); -} -#endif // !CAPNP_LITE -inline void GroupCreate::Builder::setGroupDetails( - ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Reader - value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>:: - set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: - Builder - GroupCreate::Builder::initGroupDetails() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>:: - init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Reader GroupCreate::Reader::getGroupDetails() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Builder GroupCreate::Builder::getGroupDetails() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Pipeline GroupCreate::Pipeline::getGroupDetails() { + return ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void GroupCreate::Builder::setGroupDetails( ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Builder GroupCreate::Builder::initGroupDetails() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void GroupCreate::Builder::adoptGroupDetails( - ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>&& - value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails> -GroupCreate::Builder::disownGroupDetails() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails> GroupCreate::Builder::disownGroupDetails() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool GroupCreate::GroupCreateDetails::Reader::hasUri() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool GroupCreate::GroupCreateDetails::Builder::hasUri() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::Text::Reader GroupCreate::GroupCreateDetails::Reader::getUri() - const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder -GroupCreate::GroupCreateDetails::Builder::getUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void GroupCreate::GroupCreateDetails::Builder::setUri( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::Text::Builder GroupCreate::GroupCreateDetails::Builder::initUri( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader GroupCreate::GroupCreateDetails::Reader::getUri() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder GroupCreate::GroupCreateDetails::Builder::getUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void GroupCreate::GroupCreateDetails::Builder::setUri( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder GroupCreate::GroupCreateDetails::Builder::initUri(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void GroupCreate::GroupCreateDetails::Builder::adoptUri( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -GroupCreate::GroupCreateDetails::Builder::disownUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> GroupCreate::GroupCreateDetails::Builder::disownUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool GlobalWriteState::Reader::hasCellsWritten() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool GlobalWriteState::Builder::hasCellsWritten() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::MapUInt64::Reader -GlobalWriteState::Reader::getCellsWritten() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapUInt64::Reader GlobalWriteState::Reader::getCellsWritten() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder -GlobalWriteState::Builder::getCellsWritten() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder GlobalWriteState::Builder::getCellsWritten() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline -GlobalWriteState::Pipeline::getCellsWritten() { - return ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline GlobalWriteState::Pipeline::getCellsWritten() { + return ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void GlobalWriteState::Builder::setCellsWritten( - ::tiledb::sm::serialization::capnp::MapUInt64::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void GlobalWriteState::Builder::setCellsWritten( ::tiledb::sm::serialization::capnp::MapUInt64::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder -GlobalWriteState::Builder::initCellsWritten() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder GlobalWriteState::Builder::initCellsWritten() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void GlobalWriteState::Builder::adoptCellsWritten( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapUInt64>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapUInt64>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapUInt64> -GlobalWriteState::Builder::disownCellsWritten() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapUInt64> GlobalWriteState::Builder::disownCellsWritten() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool GlobalWriteState::Reader::hasFragMeta() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool GlobalWriteState::Builder::hasFragMeta() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader -GlobalWriteState::Reader::getFragMeta() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader GlobalWriteState::Reader::getFragMeta() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder -GlobalWriteState::Builder::getFragMeta() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder GlobalWriteState::Builder::getFragMeta() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline -GlobalWriteState::Pipeline::getFragMeta() { - return ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline( - _typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline GlobalWriteState::Pipeline::getFragMeta() { + return ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline(_typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void GlobalWriteState::Builder::setFragMeta( - ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void GlobalWriteState::Builder::setFragMeta( ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder -GlobalWriteState::Builder::initFragMeta() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::FragmentMetadata>:: - init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder GlobalWriteState::Builder::initFragMeta() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void GlobalWriteState::Builder::adoptFragMeta( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata>&& - value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::FragmentMetadata>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata> -GlobalWriteState::Builder::disownFragMeta() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::FragmentMetadata>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata> GlobalWriteState::Builder::disownFragMeta() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool GlobalWriteState::Reader::hasLastCellCoords() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool GlobalWriteState::Builder::hasLastCellCoords() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::SingleCoord::Reader -GlobalWriteState::Reader::getLastCellCoords() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::SingleCoord>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SingleCoord::Reader GlobalWriteState::Reader::getLastCellCoords() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SingleCoord>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::SingleCoord::Builder -GlobalWriteState::Builder::getLastCellCoords() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::SingleCoord>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SingleCoord::Builder GlobalWriteState::Builder::getLastCellCoords() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SingleCoord>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::SingleCoord::Pipeline -GlobalWriteState::Pipeline::getLastCellCoords() { - return ::tiledb::sm::serialization::capnp::SingleCoord::Pipeline( - _typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::SingleCoord::Pipeline GlobalWriteState::Pipeline::getLastCellCoords() { + return ::tiledb::sm::serialization::capnp::SingleCoord::Pipeline(_typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void GlobalWriteState::Builder::setLastCellCoords( - ::tiledb::sm::serialization::capnp::SingleCoord::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::SingleCoord>:: - set(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void GlobalWriteState::Builder::setLastCellCoords( ::tiledb::sm::serialization::capnp::SingleCoord::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SingleCoord>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::SingleCoord::Builder -GlobalWriteState::Builder::initLastCellCoords() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::SingleCoord>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SingleCoord::Builder GlobalWriteState::Builder::initLastCellCoords() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SingleCoord>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void GlobalWriteState::Builder::adoptLastCellCoords( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::SingleCoord>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::SingleCoord>:: - adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SingleCoord>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SingleCoord>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::SingleCoord> -GlobalWriteState::Builder::disownLastCellCoords() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::SingleCoord>::disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SingleCoord> GlobalWriteState::Builder::disownLastCellCoords() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SingleCoord>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::uint64_t GlobalWriteState::Reader::getLastHilbertValue() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t GlobalWriteState::Reader::getLastHilbertValue() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t GlobalWriteState::Builder::getLastHilbertValue() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t GlobalWriteState::Builder::getLastHilbertValue() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void GlobalWriteState::Builder::setLastHilbertValue(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void GlobalWriteState::Builder::setLastHilbertValue( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool GlobalWriteState::Reader::hasMultiPartUploadStates() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool GlobalWriteState::Builder::hasMultiPartUploadStates() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); -} -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Reader -GlobalWriteState::Reader::getMultiPartUploadStates() const { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>>:: - get(_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Builder -GlobalWriteState::Builder::getMultiPartUploadStates() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>>:: - get(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Pipeline -GlobalWriteState::Pipeline::getMultiPartUploadStates() { - return ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>:: - Pipeline(_typeless.getPointerField(3)); -} -#endif // !CAPNP_LITE -inline void GlobalWriteState::Builder::setMultiPartUploadStates( - ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Reader - value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>>:: - set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Builder -GlobalWriteState::Builder::initMultiPartUploadStates() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>>:: - init(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Reader GlobalWriteState::Reader::getMultiPartUploadStates() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Builder GlobalWriteState::Builder::getMultiPartUploadStates() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Pipeline GlobalWriteState::Pipeline::getMultiPartUploadStates() { + return ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Pipeline(_typeless.getPointerField(3)); +} +#endif // !CAPNP_LITE +inline void GlobalWriteState::Builder::setMultiPartUploadStates( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Builder GlobalWriteState::Builder::initMultiPartUploadStates() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void GlobalWriteState::Builder::adoptMultiPartUploadStates( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>>:: - adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>> -GlobalWriteState::Builder::disownMultiPartUploadStates() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::MultiPartUploadState>>:: - disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>> GlobalWriteState::Builder::disownMultiPartUploadStates() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool SingleCoord::Reader::hasCoords() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool SingleCoord::Builder::hasCoords() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader -SingleCoord::Reader::getCoords() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -SingleCoord::Builder::getCoords() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void SingleCoord::Builder::setCoords( - ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline void SingleCoord::Builder::setCoords( - ::kj::ArrayPtr< - const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> - value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -SingleCoord::Builder::initCoords(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader SingleCoord::Reader::getCoords() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder SingleCoord::Builder::getCoords() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void SingleCoord::Builder::setCoords( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline void SingleCoord::Builder::setCoords(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder SingleCoord::Builder::initCoords(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void SingleCoord::Builder::adoptCoords( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> -SingleCoord::Builder::disownCoords() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> SingleCoord::Builder::disownCoords() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool SingleCoord::Reader::hasSizes() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool SingleCoord::Builder::hasSizes() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -SingleCoord::Reader::getSizes() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -SingleCoord::Builder::getSizes() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void SingleCoord::Builder::setSizes( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline void SingleCoord::Builder::setSizes( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -SingleCoord::Builder::initSizes(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader SingleCoord::Reader::getSizes() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder SingleCoord::Builder::getSizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void SingleCoord::Builder::setSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline void SingleCoord::Builder::setSizes(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder SingleCoord::Builder::initSizes(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void SingleCoord::Builder::adoptSizes( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -SingleCoord::Builder::disownSizes() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> SingleCoord::Builder::disownSizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool SingleCoord::Reader::hasSingleOffset() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool SingleCoord::Builder::hasSingleOffset() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -SingleCoord::Reader::getSingleOffset() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -SingleCoord::Builder::getSingleOffset() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void SingleCoord::Builder::setSingleOffset( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline void SingleCoord::Builder::setSingleOffset( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -SingleCoord::Builder::initSingleOffset(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader SingleCoord::Reader::getSingleOffset() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder SingleCoord::Builder::getSingleOffset() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void SingleCoord::Builder::setSingleOffset( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline void SingleCoord::Builder::setSingleOffset(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder SingleCoord::Builder::initSingleOffset(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void SingleCoord::Builder::adoptSingleOffset( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -SingleCoord::Builder::disownSingleOffset() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> SingleCoord::Builder::disownSingleOffset() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasFileSizes() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasFileSizes() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -FragmentMetadata::Reader::getFileSizes() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::Builder::getFileSizes() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setFileSizes( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setFileSizes( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::Builder::initFileSizes(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::Reader::getFileSizes() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::getFileSizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setFileSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setFileSizes(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::initFileSizes(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptFileSizes( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -FragmentMetadata::Builder::disownFileSizes() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::Builder::disownFileSizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasFileVarSizes() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasFileVarSizes() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -FragmentMetadata::Reader::getFileVarSizes() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::Builder::getFileVarSizes() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setFileVarSizes( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setFileVarSizes( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::Builder::initFileVarSizes(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::Reader::getFileVarSizes() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::getFileVarSizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setFileVarSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setFileVarSizes(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::initFileVarSizes(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptFileVarSizes( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -FragmentMetadata::Builder::disownFileVarSizes() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::Builder::disownFileVarSizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasFileValiditySizes() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasFileValiditySizes() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -FragmentMetadata::Reader::getFileValiditySizes() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::Builder::getFileValiditySizes() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setFileValiditySizes( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setFileValiditySizes( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::Builder::initFileValiditySizes(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::Reader::getFileValiditySizes() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::getFileValiditySizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setFileValiditySizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setFileValiditySizes(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::initFileValiditySizes(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptFileValiditySizes( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -FragmentMetadata::Builder::disownFileValiditySizes() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::Builder::disownFileValiditySizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasFragmentUri() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasFragmentUri() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader FragmentMetadata::Reader::getFragmentUri() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader FragmentMetadata::Reader::getFragmentUri() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder FragmentMetadata::Builder::getFragmentUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder FragmentMetadata::Builder::getFragmentUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline void FragmentMetadata::Builder::setFragmentUri( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); +inline void FragmentMetadata::Builder::setFragmentUri( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder FragmentMetadata::Builder::initFragmentUri( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder FragmentMetadata::Builder::initFragmentUri(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptFragmentUri( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -FragmentMetadata::Builder::disownFragmentUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> FragmentMetadata::Builder::disownFragmentUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::getHasTimestamps() const { - return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool FragmentMetadata::Builder::getHasTimestamps() { - return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void FragmentMetadata::Builder::setHasTimestamps(bool value) { - _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool FragmentMetadata::Reader::getHasDeleteMeta() const { - return _reader.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline bool FragmentMetadata::Builder::getHasDeleteMeta() { - return _builder.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline void FragmentMetadata::Builder::setHasDeleteMeta(bool value) { - _builder.setDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t FragmentMetadata::Reader::getSparseTileNum() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t FragmentMetadata::Reader::getSparseTileNum() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t FragmentMetadata::Builder::getSparseTileNum() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t FragmentMetadata::Builder::getSparseTileNum() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void FragmentMetadata::Builder::setSparseTileNum(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void FragmentMetadata::Builder::setSparseTileNum( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t FragmentMetadata::Reader::getTileIndexBase() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t FragmentMetadata::Reader::getTileIndexBase() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t FragmentMetadata::Builder::getTileIndexBase() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t FragmentMetadata::Builder::getTileIndexBase() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void FragmentMetadata::Builder::setTileIndexBase(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void FragmentMetadata::Builder::setTileIndexBase( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool FragmentMetadata::Reader::hasTileOffsets() const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasTileOffsets() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader -FragmentMetadata::Reader::getTileOffsets() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_reader - .getPointerField( - ::capnp::bounded<4>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::getTileOffsets() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_builder - .getPointerField( - ::capnp::bounded<4>() * - ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileOffsets( - ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setTileOffsets( - ::kj::ArrayPtr< - const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> - value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::initTileOffsets(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - init( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileOffsets( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setTileOffsets(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptTileOffsets( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> -FragmentMetadata::Builder::disownTileOffsets() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::disown(_builder - .getPointerField( - ::capnp::bounded<4>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileVarOffsets() const { - return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasTileVarOffsets() { - return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader -FragmentMetadata::Reader::getTileVarOffsets() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_reader - .getPointerField( - ::capnp::bounded<5>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::getTileVarOffsets() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_builder - .getPointerField( - ::capnp::bounded<5>() * - ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileVarOffsets( - ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setTileVarOffsets( - ::kj::ArrayPtr< - const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> - value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::initTileVarOffsets(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - init( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileVarOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileVarOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileVarOffsets( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setTileVarOffsets(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileVarOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptTileVarOffsets( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - adopt( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> -FragmentMetadata::Builder::disownTileVarOffsets() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::disown(_builder - .getPointerField( - ::capnp::bounded<5>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileVarOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileVarSizes() const { - return !_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasTileVarSizes() { - return !_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader -FragmentMetadata::Reader::getTileVarSizes() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_reader - .getPointerField( - ::capnp::bounded<6>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::getTileVarSizes() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_builder - .getPointerField( - ::capnp::bounded<6>() * - ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileVarSizes( - ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setTileVarSizes( - ::kj::ArrayPtr< - const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> - value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::initTileVarSizes(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - init( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileVarSizes() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileVarSizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileVarSizes( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setTileVarSizes(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileVarSizes(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptTileVarSizes( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - adopt( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> -FragmentMetadata::Builder::disownTileVarSizes() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::disown(_builder - .getPointerField( - ::capnp::bounded<6>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileVarSizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileValidityOffsets() const { - return !_reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasTileValidityOffsets() { - return !_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader -FragmentMetadata::Reader::getTileValidityOffsets() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_reader - .getPointerField( - ::capnp::bounded<7>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::getTileValidityOffsets() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_builder - .getPointerField( - ::capnp::bounded<7>() * - ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileValidityOffsets( - ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setTileValidityOffsets( - ::kj::ArrayPtr< - const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> - value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::initTileValidityOffsets(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - init( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileValidityOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileValidityOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileValidityOffsets( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setTileValidityOffsets(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileValidityOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptTileValidityOffsets( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - adopt( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> -FragmentMetadata::Builder::disownTileValidityOffsets() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::disown(_builder - .getPointerField( - ::capnp::bounded<7>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileValidityOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileMinBuffer() const { - return !_reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasTileMinBuffer() { - return !_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader -FragmentMetadata::Reader::getTileMinBuffer() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_reader - .getPointerField( - ::capnp::bounded<8>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::getTileMinBuffer() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_builder - .getPointerField( - ::capnp::bounded<8>() * - ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileMinBuffer( - ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setTileMinBuffer( - ::kj::ArrayPtr< - const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> - value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::initTileMinBuffer(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - init( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileMinBuffer() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileMinBuffer() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileMinBuffer( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setTileMinBuffer(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileMinBuffer(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptTileMinBuffer( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - adopt( - _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> -FragmentMetadata::Builder::disownTileMinBuffer() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::disown(_builder - .getPointerField( - ::capnp::bounded<8>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileMinBuffer() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<8>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileMinVarBuffer() const { - return !_reader.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasTileMinVarBuffer() { - return !_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader -FragmentMetadata::Reader::getTileMinVarBuffer() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_reader - .getPointerField( - ::capnp::bounded<9>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::getTileMinVarBuffer() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_builder - .getPointerField( - ::capnp::bounded<9>() * - ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileMinVarBuffer( - ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setTileMinVarBuffer( - ::kj::ArrayPtr< - const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> - value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::initTileMinVarBuffer(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - init( - _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileMinVarBuffer() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileMinVarBuffer() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileMinVarBuffer( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setTileMinVarBuffer(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileMinVarBuffer(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptTileMinVarBuffer( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - adopt( - _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> -FragmentMetadata::Builder::disownTileMinVarBuffer() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::disown(_builder - .getPointerField( - ::capnp::bounded<9>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileMinVarBuffer() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<9>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileMaxBuffer() const { - return !_reader.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasTileMaxBuffer() { - return !_builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader -FragmentMetadata::Reader::getTileMaxBuffer() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_reader - .getPointerField( - ::capnp::bounded<10>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::getTileMaxBuffer() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_builder - .getPointerField( - ::capnp::bounded<10>() * - ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileMaxBuffer( - ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setTileMaxBuffer( - ::kj::ArrayPtr< - const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> - value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::initTileMaxBuffer(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - init( - _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileMaxBuffer() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileMaxBuffer() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileMaxBuffer( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setTileMaxBuffer(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileMaxBuffer(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptTileMaxBuffer( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - adopt( - _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> -FragmentMetadata::Builder::disownTileMaxBuffer() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::disown(_builder - .getPointerField( - ::capnp::bounded<10>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileMaxBuffer() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<10>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileMaxVarBuffer() const { - return !_reader.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasTileMaxVarBuffer() { - return !_builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader -FragmentMetadata::Reader::getTileMaxVarBuffer() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_reader - .getPointerField( - ::capnp::bounded<11>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::getTileMaxVarBuffer() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_builder - .getPointerField( - ::capnp::bounded<11>() * - ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileMaxVarBuffer( - ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setTileMaxVarBuffer( - ::kj::ArrayPtr< - const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> - value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::initTileMaxVarBuffer(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - init( - _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileMaxVarBuffer() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileMaxVarBuffer() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileMaxVarBuffer( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setTileMaxVarBuffer(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileMaxVarBuffer(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptTileMaxVarBuffer( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - adopt( - _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> -FragmentMetadata::Builder::disownTileMaxVarBuffer() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::disown(_builder - .getPointerField( - ::capnp::bounded<11>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileMaxVarBuffer() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<11>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileSums() const { - return !_reader.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasTileSums() { - return !_builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader -FragmentMetadata::Reader::getTileSums() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_reader - .getPointerField( - ::capnp::bounded<12>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::getTileSums() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_builder - .getPointerField( - ::capnp::bounded<12>() * - ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileSums( - ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setTileSums( - ::kj::ArrayPtr< - const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> - value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::initTileSums(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - init( - _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileSums() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileSums() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileSums( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setTileSums(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileSums(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptTileSums( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - adopt( - _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> -FragmentMetadata::Builder::disownTileSums() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::disown(_builder - .getPointerField( - ::capnp::bounded<12>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileSums() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<12>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileNullCounts() const { - return !_reader.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasTileNullCounts() { - return !_builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader -FragmentMetadata::Reader::getTileNullCounts() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_reader - .getPointerField( - ::capnp::bounded<13>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::getTileNullCounts() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_builder - .getPointerField( - ::capnp::bounded<13>() * - ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileNullCounts( - ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setTileNullCounts( - ::kj::ArrayPtr< - const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> - value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::initTileNullCounts(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - init( - _builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileNullCounts() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileNullCounts() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileNullCounts( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setTileNullCounts(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileNullCounts(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptTileNullCounts( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - adopt( - _builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> -FragmentMetadata::Builder::disownTileNullCounts() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::disown(_builder - .getPointerField( - ::capnp::bounded<13>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileNullCounts() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<13>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasFragmentMins() const { - return !_reader.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasFragmentMins() { - return !_builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader -FragmentMetadata::Reader::getFragmentMins() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_reader - .getPointerField( - ::capnp::bounded<14>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::getFragmentMins() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_builder - .getPointerField( - ::capnp::bounded<14>() * - ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setFragmentMins( - ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setFragmentMins( - ::kj::ArrayPtr< - const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> - value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::initFragmentMins(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - init( - _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getFragmentMins() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getFragmentMins() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setFragmentMins( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setFragmentMins(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initFragmentMins(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptFragmentMins( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - adopt( - _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> -FragmentMetadata::Builder::disownFragmentMins() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::disown(_builder - .getPointerField( - ::capnp::bounded<14>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownFragmentMins() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<14>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasFragmentMaxs() const { - return !_reader.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasFragmentMaxs() { - return !_builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader -FragmentMetadata::Reader::getFragmentMaxs() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_reader - .getPointerField( - ::capnp::bounded<15>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::getFragmentMaxs() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::get(_builder - .getPointerField( - ::capnp::bounded<15>() * - ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setFragmentMaxs( - ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setFragmentMaxs( - ::kj::ArrayPtr< - const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> - value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>::Builder -FragmentMetadata::Builder::initFragmentMaxs(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - init( - _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getFragmentMaxs() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getFragmentMaxs() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setFragmentMaxs( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setFragmentMaxs(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initFragmentMaxs(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptFragmentMaxs( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>:: - adopt( - _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>> -FragmentMetadata::Builder::disownFragmentMaxs() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, - ::capnp::Kind::LIST>>::disown(_builder - .getPointerField( - ::capnp::bounded<15>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownFragmentMaxs() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<15>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasFragmentSums() const { - return !_reader.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasFragmentSums() { - return !_builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -FragmentMetadata::Reader::getFragmentSums() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::Builder::getFragmentSums() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setFragmentSums( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setFragmentSums( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::Builder::initFragmentSums(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::Reader::getFragmentSums() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::getFragmentSums() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setFragmentSums( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setFragmentSums(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::initFragmentSums(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptFragmentSums( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -FragmentMetadata::Builder::disownFragmentSums() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::Builder::disownFragmentSums() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<16>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasFragmentNullCounts() const { - return !_reader.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasFragmentNullCounts() { - return !_builder.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -FragmentMetadata::Reader::getFragmentNullCounts() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::Builder::getFragmentNullCounts() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setFragmentNullCounts( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setFragmentNullCounts( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::Builder::initFragmentNullCounts(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::Reader::getFragmentNullCounts() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::getFragmentNullCounts() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setFragmentNullCounts( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setFragmentNullCounts(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::initFragmentNullCounts(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptFragmentNullCounts( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -FragmentMetadata::Builder::disownFragmentNullCounts() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS)); -} - -inline ::uint32_t FragmentMetadata::Reader::getVersion() const { - return _reader.getDataField<::uint32_t>( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::Builder::disownFragmentNullCounts() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<17>() * ::capnp::POINTERS)); +} + +inline ::uint32_t FragmentMetadata::Reader::getVersion() const { + return _reader.getDataField< ::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint32_t FragmentMetadata::Builder::getVersion() { - return _builder.getDataField<::uint32_t>( +inline ::uint32_t FragmentMetadata::Builder::getVersion() { + return _builder.getDataField< ::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void FragmentMetadata::Builder::setVersion(::uint32_t value) { - _builder.setDataField<::uint32_t>( +inline void FragmentMetadata::Builder::setVersion( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool FragmentMetadata::Reader::hasTimestampRange() const { - return !_reader.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasTimestampRange() { - return !_builder.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -FragmentMetadata::Reader::getTimestampRange() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::Builder::getTimestampRange() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTimestampRange( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::Builder::setTimestampRange( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::Builder::initTimestampRange(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::Reader::getTimestampRange() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::getTimestampRange() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTimestampRange( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::Builder::setTimestampRange(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::initTimestampRange(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptTimestampRange( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -FragmentMetadata::Builder::disownTimestampRange() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS)); -} - -inline ::uint64_t FragmentMetadata::Reader::getLastTileCellNum() const { - return _reader.getDataField<::uint64_t>( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::Builder::disownTimestampRange() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<18>() * ::capnp::POINTERS)); +} + +inline ::uint64_t FragmentMetadata::Reader::getLastTileCellNum() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS); } -inline ::uint64_t FragmentMetadata::Builder::getLastTileCellNum() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t FragmentMetadata::Builder::getLastTileCellNum() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS); } -inline void FragmentMetadata::Builder::setLastTileCellNum(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void FragmentMetadata::Builder::setLastTileCellNum( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS, value); } inline bool FragmentMetadata::Reader::hasNonEmptyDomain() const { - return !_reader.getPointerField(::capnp::bounded<19>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasNonEmptyDomain() { - return !_builder.getPointerField(::capnp::bounded<19>() * ::capnp::POINTERS) - .isNull(); -} -inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader -FragmentMetadata::Reader::getNonEmptyDomain() const { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: - get(_reader.getPointerField(::capnp::bounded<19>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder -FragmentMetadata::Builder::getNonEmptyDomain() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: - get(_builder.getPointerField(::capnp::bounded<19>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline -FragmentMetadata::Pipeline::getNonEmptyDomain() { - return ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline( - _typeless.getPointerField(19)); -} -#endif // !CAPNP_LITE -inline void FragmentMetadata::Builder::setNonEmptyDomain( - ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: - set(_builder.getPointerField(::capnp::bounded<19>() * ::capnp::POINTERS), - value); -} -inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder -FragmentMetadata::Builder::initNonEmptyDomain() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: - init( - _builder.getPointerField(::capnp::bounded<19>() * ::capnp::POINTERS)); + return !_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS).isNull(); +} +inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader FragmentMetadata::Reader::getNonEmptyDomain() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::get(_reader.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder FragmentMetadata::Builder::getNonEmptyDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::get(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline FragmentMetadata::Pipeline::getNonEmptyDomain() { + return ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline(_typeless.getPointerField(19)); +} +#endif // !CAPNP_LITE +inline void FragmentMetadata::Builder::setNonEmptyDomain( ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::set(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS), value); +} +inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder FragmentMetadata::Builder::initNonEmptyDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::init(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS)); } inline void FragmentMetadata::Builder::adoptNonEmptyDomain( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::NonEmptyDomainList>&& - value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: - adopt( - _builder.getPointerField(::capnp::bounded<19>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::NonEmptyDomainList> -FragmentMetadata::Builder::disownNonEmptyDomain() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: - disown( - _builder.getPointerField(::capnp::bounded<19>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::adopt(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NonEmptyDomainList> FragmentMetadata::Builder::disownNonEmptyDomain() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::disown(_builder.getPointerField( + ::capnp::bounded<19>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasRtree() const { - return !_reader.getPointerField(::capnp::bounded<20>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<20>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasRtree() { - return !_builder.getPointerField(::capnp::bounded<20>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<20>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Data::Reader FragmentMetadata::Reader::getRtree() const { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _reader.getPointerField(::capnp::bounded<20>() * ::capnp::POINTERS)); +inline ::capnp::Data::Reader FragmentMetadata::Reader::getRtree() const { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( + ::capnp::bounded<20>() * ::capnp::POINTERS)); } -inline ::capnp::Data::Builder FragmentMetadata::Builder::getRtree() { - return ::capnp::_::PointerHelpers<::capnp::Data>::get( - _builder.getPointerField(::capnp::bounded<20>() * ::capnp::POINTERS)); +inline ::capnp::Data::Builder FragmentMetadata::Builder::getRtree() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( + ::capnp::bounded<20>() * ::capnp::POINTERS)); } -inline void FragmentMetadata::Builder::setRtree(::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Data>::set( - _builder.getPointerField(::capnp::bounded<20>() * ::capnp::POINTERS), - value); +inline void FragmentMetadata::Builder::setRtree( ::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( + ::capnp::bounded<20>() * ::capnp::POINTERS), value); } -inline ::capnp::Data::Builder FragmentMetadata::Builder::initRtree( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Data>::init( - _builder.getPointerField(::capnp::bounded<20>() * ::capnp::POINTERS), - size); +inline ::capnp::Data::Builder FragmentMetadata::Builder::initRtree(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( + ::capnp::bounded<20>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptRtree( - ::capnp::Orphan<::capnp::Data>&& value) { - ::capnp::_::PointerHelpers<::capnp::Data>::adopt( - _builder.getPointerField(::capnp::bounded<20>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Data>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( + ::capnp::bounded<20>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Data> FragmentMetadata::Builder::disownRtree() { - return ::capnp::_::PointerHelpers<::capnp::Data>::disown( - _builder.getPointerField(::capnp::bounded<20>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Data> FragmentMetadata::Builder::disownRtree() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( + ::capnp::bounded<20>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::getHasConsolidatedFooter() const { - return _reader.getDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); } inline bool FragmentMetadata::Builder::getHasConsolidatedFooter() { - return _builder.getDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); } inline void FragmentMetadata::Builder::setHasConsolidatedFooter(bool value) { - _builder.setDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool FragmentMetadata::Reader::hasGtOffsets() const { - return !_reader.getPointerField(::capnp::bounded<21>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<21>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasGtOffsets() { - return !_builder.getPointerField(::capnp::bounded<21>() * ::capnp::POINTERS) - .isNull(); -} -inline ::tiledb::sm::serialization::capnp::FragmentMetadata:: - GenericTileOffsets::Reader - FragmentMetadata::Reader::getGtOffsets() const { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp:: - FragmentMetadata::GenericTileOffsets>:: - get(_reader.getPointerField(::capnp::bounded<21>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::FragmentMetadata:: - GenericTileOffsets::Builder - FragmentMetadata::Builder::getGtOffsets() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp:: - FragmentMetadata::GenericTileOffsets>:: - get(_builder.getPointerField(::capnp::bounded<21>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FragmentMetadata:: - GenericTileOffsets::Pipeline - FragmentMetadata::Pipeline::getGtOffsets() { - return ::tiledb::sm::serialization::capnp::FragmentMetadata:: - GenericTileOffsets::Pipeline(_typeless.getPointerField(21)); -} -#endif // !CAPNP_LITE -inline void FragmentMetadata::Builder::setGtOffsets( - ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets:: - Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp:: - FragmentMetadata::GenericTileOffsets>:: - set(_builder.getPointerField(::capnp::bounded<21>() * ::capnp::POINTERS), - value); -} -inline ::tiledb::sm::serialization::capnp::FragmentMetadata:: - GenericTileOffsets::Builder - FragmentMetadata::Builder::initGtOffsets() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp:: - FragmentMetadata::GenericTileOffsets>:: - init( - _builder.getPointerField(::capnp::bounded<21>() * ::capnp::POINTERS)); + return !_builder.getPointerField( + ::capnp::bounded<21>() * ::capnp::POINTERS).isNull(); +} +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Reader FragmentMetadata::Reader::getGtOffsets() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets>::get(_reader.getPointerField( + ::capnp::bounded<21>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Builder FragmentMetadata::Builder::getGtOffsets() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets>::get(_builder.getPointerField( + ::capnp::bounded<21>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Pipeline FragmentMetadata::Pipeline::getGtOffsets() { + return ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Pipeline(_typeless.getPointerField(21)); +} +#endif // !CAPNP_LITE +inline void FragmentMetadata::Builder::setGtOffsets( ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets>::set(_builder.getPointerField( + ::capnp::bounded<21>() * ::capnp::POINTERS), value); +} +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Builder FragmentMetadata::Builder::initGtOffsets() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets>::init(_builder.getPointerField( + ::capnp::bounded<21>() * ::capnp::POINTERS)); } inline void FragmentMetadata::Builder::adoptGtOffsets( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata:: - GenericTileOffsets>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp:: - FragmentMetadata::GenericTileOffsets>:: - adopt( - _builder.getPointerField(::capnp::bounded<21>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets> -FragmentMetadata::Builder::disownGtOffsets() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp:: - FragmentMetadata::GenericTileOffsets>:: - disown( - _builder.getPointerField(::capnp::bounded<21>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets>::adopt(_builder.getPointerField( + ::capnp::bounded<21>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets> FragmentMetadata::Builder::disownGtOffsets() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets>::disown(_builder.getPointerField( + ::capnp::bounded<21>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasArraySchemaName() const { - return !_reader.getPointerField(::capnp::bounded<22>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<22>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::Builder::hasArraySchemaName() { - return !_builder.getPointerField(::capnp::bounded<22>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::Text::Reader FragmentMetadata::Reader::getArraySchemaName() - const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<22>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder FragmentMetadata::Builder::getArraySchemaName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<22>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setArraySchemaName( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<22>() * ::capnp::POINTERS), - value); -} -inline ::capnp::Text::Builder FragmentMetadata::Builder::initArraySchemaName( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<22>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<22>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader FragmentMetadata::Reader::getArraySchemaName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<22>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder FragmentMetadata::Builder::getArraySchemaName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<22>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setArraySchemaName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<22>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder FragmentMetadata::Builder::initArraySchemaName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<22>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::Builder::adoptArraySchemaName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<22>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<22>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -FragmentMetadata::Builder::disownArraySchemaName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<22>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> FragmentMetadata::Builder::disownArraySchemaName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<22>() * ::capnp::POINTERS)); } -inline ::uint64_t FragmentMetadata::GenericTileOffsets::Reader::getRtree() - const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t FragmentMetadata::GenericTileOffsets::Reader::getRtree() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t FragmentMetadata::GenericTileOffsets::Builder::getRtree() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t FragmentMetadata::GenericTileOffsets::Builder::getRtree() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void FragmentMetadata::GenericTileOffsets::Builder::setRtree( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void FragmentMetadata::GenericTileOffsets::Builder::setRtree( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileOffsets() - const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); +inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileOffsets() const { + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::GenericTileOffsets::Builder::hasTileOffsets() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -FragmentMetadata::GenericTileOffsets::Reader::getTileOffsets() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::GenericTileOffsets::Builder::getTileOffsets() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileOffsets( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileOffsets( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::GenericTileOffsets::Builder::initTileOffsets( - unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::GenericTileOffsets::Reader::getTileOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::getTileOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileOffsets(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::initTileOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::GenericTileOffsets::Builder::adoptTileOffsets( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -FragmentMetadata::GenericTileOffsets::Builder::disownTileOffsets() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); -} - -inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileVarOffsets() - const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::GenericTileOffsets::Builder::disownTileOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileVarOffsets() const { + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::GenericTileOffsets::Builder::hasTileVarOffsets() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -FragmentMetadata::GenericTileOffsets::Reader::getTileVarOffsets() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::GenericTileOffsets::Builder::getTileVarOffsets() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileVarOffsets( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileVarOffsets( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::GenericTileOffsets::Builder::initTileVarOffsets( - unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::GenericTileOffsets::Reader::getTileVarOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::getTileVarOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileVarOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileVarOffsets(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::initTileVarOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::GenericTileOffsets::Builder::adoptTileVarOffsets( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -FragmentMetadata::GenericTileOffsets::Builder::disownTileVarOffsets() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} - -inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileVarSizes() - const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::GenericTileOffsets::Builder::disownTileVarOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileVarSizes() const { + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::GenericTileOffsets::Builder::hasTileVarSizes() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -FragmentMetadata::GenericTileOffsets::Reader::getTileVarSizes() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::GenericTileOffsets::Builder::getTileVarSizes() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileVarSizes( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileVarSizes( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::GenericTileOffsets::Builder::initTileVarSizes( - unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::GenericTileOffsets::Reader::getTileVarSizes() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::getTileVarSizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileVarSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileVarSizes(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::initTileVarSizes(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::GenericTileOffsets::Builder::adoptTileVarSizes( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -FragmentMetadata::GenericTileOffsets::Builder::disownTileVarSizes() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); -} - -inline bool -FragmentMetadata::GenericTileOffsets::Reader::hasTileValidityOffsets() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); -} -inline bool -FragmentMetadata::GenericTileOffsets::Builder::hasTileValidityOffsets() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -FragmentMetadata::GenericTileOffsets::Reader::getTileValidityOffsets() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::GenericTileOffsets::Builder::getTileValidityOffsets() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline void -FragmentMetadata::GenericTileOffsets::Builder::setTileValidityOffsets( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline void -FragmentMetadata::GenericTileOffsets::Builder::setTileValidityOffsets( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::GenericTileOffsets::Builder::initTileValidityOffsets( - unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - size); -} -inline void -FragmentMetadata::GenericTileOffsets::Builder::adoptTileValidityOffsets( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -FragmentMetadata::GenericTileOffsets::Builder::disownTileValidityOffsets() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} - -inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileMinOffsets() - const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::GenericTileOffsets::Builder::disownTileVarSizes() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileValidityOffsets() const { + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline bool FragmentMetadata::GenericTileOffsets::Builder::hasTileValidityOffsets() { + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::GenericTileOffsets::Reader::getTileValidityOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::getTileValidityOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileValidityOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileValidityOffsets(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::initTileValidityOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::adoptTileValidityOffsets( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::GenericTileOffsets::Builder::disownTileValidityOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileMinOffsets() const { + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::GenericTileOffsets::Builder::hasTileMinOffsets() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -FragmentMetadata::GenericTileOffsets::Reader::getTileMinOffsets() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::GenericTileOffsets::Builder::getTileMinOffsets() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileMinOffsets( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileMinOffsets( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::GenericTileOffsets::Builder::initTileMinOffsets( - unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::GenericTileOffsets::Reader::getTileMinOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::getTileMinOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileMinOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileMinOffsets(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::initTileMinOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::GenericTileOffsets::Builder::adoptTileMinOffsets( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -FragmentMetadata::GenericTileOffsets::Builder::disownTileMinOffsets() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); -} - -inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileMaxOffsets() - const { - return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::GenericTileOffsets::Builder::disownTileMinOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} + +inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileMaxOffsets() const { + return !_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::GenericTileOffsets::Builder::hasTileMaxOffsets() { - return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -FragmentMetadata::GenericTileOffsets::Reader::getTileMaxOffsets() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::GenericTileOffsets::Builder::getTileMaxOffsets() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileMaxOffsets( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileMaxOffsets( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::GenericTileOffsets::Builder::initTileMaxOffsets( - unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::GenericTileOffsets::Reader::getTileMaxOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::getTileMaxOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileMaxOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileMaxOffsets(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::initTileMaxOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::GenericTileOffsets::Builder::adoptTileMaxOffsets( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -FragmentMetadata::GenericTileOffsets::Builder::disownTileMaxOffsets() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); -} - -inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileSumOffsets() - const { - return !_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) - .isNull(); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::GenericTileOffsets::Builder::disownTileMaxOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<5>() * ::capnp::POINTERS)); +} + +inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileSumOffsets() const { + return !_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); } inline bool FragmentMetadata::GenericTileOffsets::Builder::hasTileSumOffsets() { - return !_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -FragmentMetadata::GenericTileOffsets::Reader::getTileSumOffsets() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::GenericTileOffsets::Builder::getTileSumOffsets() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileSumOffsets( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - value); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileSumOffsets( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::GenericTileOffsets::Builder::initTileSumOffsets( - unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::GenericTileOffsets::Reader::getTileSumOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::getTileSumOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileSumOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileSumOffsets(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::initTileSumOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), size); } inline void FragmentMetadata::GenericTileOffsets::Builder::adoptTileSumOffsets( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -FragmentMetadata::GenericTileOffsets::Builder::disownTileSumOffsets() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); -} - -inline bool -FragmentMetadata::GenericTileOffsets::Reader::hasTileNullCountOffsets() const { - return !_reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) - .isNull(); -} -inline bool -FragmentMetadata::GenericTileOffsets::Builder::hasTileNullCountOffsets() { - return !_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -FragmentMetadata::GenericTileOffsets::Reader::getTileNullCountOffsets() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::GenericTileOffsets::Builder::getTileNullCountOffsets() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); -} -inline void -FragmentMetadata::GenericTileOffsets::Builder::setTileNullCountOffsets( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - value); -} -inline void -FragmentMetadata::GenericTileOffsets::Builder::setTileNullCountOffsets( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -FragmentMetadata::GenericTileOffsets::Builder::initTileNullCountOffsets( - unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - size); -} -inline void -FragmentMetadata::GenericTileOffsets::Builder::adoptTileNullCountOffsets( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -FragmentMetadata::GenericTileOffsets::Builder::disownTileNullCountOffsets() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); -} - -inline ::uint64_t FragmentMetadata::GenericTileOffsets::Reader:: - getFragmentMinMaxSumNullCountOffset() const { - return _reader.getDataField<::uint64_t>( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::GenericTileOffsets::Builder::disownTileSumOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<6>() * ::capnp::POINTERS)); +} + +inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileNullCountOffsets() const { + return !_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline bool FragmentMetadata::GenericTileOffsets::Builder::hasTileNullCountOffsets() { + return !_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::GenericTileOffsets::Reader::getTileNullCountOffsets() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::getTileNullCountOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileNullCountOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileNullCountOffsets(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::initTileNullCountOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), size); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::adoptTileNullCountOffsets( + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::GenericTileOffsets::Builder::disownTileNullCountOffsets() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<7>() * ::capnp::POINTERS)); +} + +inline ::uint64_t FragmentMetadata::GenericTileOffsets::Reader::getFragmentMinMaxSumNullCountOffset() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t FragmentMetadata::GenericTileOffsets::Builder:: - getFragmentMinMaxSumNullCountOffset() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t FragmentMetadata::GenericTileOffsets::Builder::getFragmentMinMaxSumNullCountOffset() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void FragmentMetadata::GenericTileOffsets::Builder:: - setFragmentMinMaxSumNullCountOffset(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void FragmentMetadata::GenericTileOffsets::Builder::setFragmentMinMaxSumNullCountOffset( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t -FragmentMetadata::GenericTileOffsets::Reader::getProcessedConditionsOffsets() - const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t FragmentMetadata::GenericTileOffsets::Reader::getProcessedConditionsOffsets() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t -FragmentMetadata::GenericTileOffsets::Builder::getProcessedConditionsOffsets() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t FragmentMetadata::GenericTileOffsets::Builder::getProcessedConditionsOffsets() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void -FragmentMetadata::GenericTileOffsets::Builder::setProcessedConditionsOffsets( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void FragmentMetadata::GenericTileOffsets::Builder::setProcessedConditionsOffsets( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t MultiPartUploadState::Reader::getPartNumber() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t MultiPartUploadState::Reader::getPartNumber() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t MultiPartUploadState::Builder::getPartNumber() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t MultiPartUploadState::Builder::getPartNumber() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void MultiPartUploadState::Builder::setPartNumber(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void MultiPartUploadState::Builder::setPartNumber( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool MultiPartUploadState::Reader::hasUploadId() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool MultiPartUploadState::Builder::hasUploadId() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader MultiPartUploadState::Reader::getUploadId() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader MultiPartUploadState::Reader::getUploadId() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder MultiPartUploadState::Builder::getUploadId() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder MultiPartUploadState::Builder::getUploadId() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void MultiPartUploadState::Builder::setUploadId( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void MultiPartUploadState::Builder::setUploadId( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder MultiPartUploadState::Builder::initUploadId( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder MultiPartUploadState::Builder::initUploadId(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void MultiPartUploadState::Builder::adoptUploadId( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -MultiPartUploadState::Builder::disownUploadId() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> MultiPartUploadState::Builder::disownUploadId() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool MultiPartUploadState::Reader::hasStatus() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool MultiPartUploadState::Builder::hasStatus() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader MultiPartUploadState::Reader::getStatus() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader MultiPartUploadState::Reader::getStatus() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder MultiPartUploadState::Builder::getStatus() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder MultiPartUploadState::Builder::getStatus() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void MultiPartUploadState::Builder::setStatus( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void MultiPartUploadState::Builder::setStatus( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder MultiPartUploadState::Builder::initStatus( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder MultiPartUploadState::Builder::initStatus(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void MultiPartUploadState::Builder::adoptStatus( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -MultiPartUploadState::Builder::disownStatus() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> MultiPartUploadState::Builder::disownStatus() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool MultiPartUploadState::Reader::hasCompletedParts() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool MultiPartUploadState::Builder::hasCompletedParts() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>::Reader -MultiPartUploadState::Reader::getCompletedParts() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<2>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>::Builder -MultiPartUploadState::Builder::getCompletedParts() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<2>() * - ::capnp::POINTERS)); -} -inline void MultiPartUploadState::Builder::setCompletedParts( - ::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>::Builder -MultiPartUploadState::Builder::initCompletedParts(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>::Reader MultiPartUploadState::Reader::getCompletedParts() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>::Builder MultiPartUploadState::Builder::getCompletedParts() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void MultiPartUploadState::Builder::setCompletedParts( ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>::Builder MultiPartUploadState::Builder::initCompletedParts(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void MultiPartUploadState::Builder::adoptCompletedParts( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>> -MultiPartUploadState::Builder::disownCompletedParts() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::CompletedPart, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<2>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>> MultiPartUploadState::Builder::disownCompletedParts() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool MultiPartUploadState::Reader::hasBufferedChunks() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool MultiPartUploadState::Builder::hasBufferedChunks() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>::Reader -MultiPartUploadState::Reader::getBufferedChunks() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<3>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>::Builder -MultiPartUploadState::Builder::getBufferedChunks() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<3>() * - ::capnp::POINTERS)); -} -inline void MultiPartUploadState::Builder::setBufferedChunks( - ::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>::Builder -MultiPartUploadState::Builder::initBufferedChunks(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>::Reader MultiPartUploadState::Reader::getBufferedChunks() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>::Builder MultiPartUploadState::Builder::getBufferedChunks() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void MultiPartUploadState::Builder::setBufferedChunks( ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>::Builder MultiPartUploadState::Builder::initBufferedChunks(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); } inline void MultiPartUploadState::Builder::adoptBufferedChunks( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>> -MultiPartUploadState::Builder::disownBufferedChunks() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::BufferedChunk, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<3>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>> MultiPartUploadState::Builder::disownBufferedChunks() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool CompletedPart::Reader::hasETag() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool CompletedPart::Builder::hasETag() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader CompletedPart::Reader::getETag() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader CompletedPart::Reader::getETag() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder CompletedPart::Builder::getETag() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder CompletedPart::Builder::getETag() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void CompletedPart::Builder::setETag(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void CompletedPart::Builder::setETag( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder CompletedPart::Builder::initETag( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder CompletedPart::Builder::initETag(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void CompletedPart::Builder::adoptETag( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> CompletedPart::Builder::disownETag() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> CompletedPart::Builder::disownETag() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t CompletedPart::Reader::getPartNumber() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t CompletedPart::Reader::getPartNumber() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t CompletedPart::Builder::getPartNumber() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t CompletedPart::Builder::getPartNumber() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void CompletedPart::Builder::setPartNumber(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void CompletedPart::Builder::setPartNumber( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool WrittenFragmentInfo::Reader::hasUri() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool WrittenFragmentInfo::Builder::hasUri() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader WrittenFragmentInfo::Reader::getUri() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader WrittenFragmentInfo::Reader::getUri() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder WrittenFragmentInfo::Builder::getUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder WrittenFragmentInfo::Builder::getUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void WrittenFragmentInfo::Builder::setUri(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void WrittenFragmentInfo::Builder::setUri( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder WrittenFragmentInfo::Builder::initUri( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder WrittenFragmentInfo::Builder::initUri(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void WrittenFragmentInfo::Builder::adoptUri( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -WrittenFragmentInfo::Builder::disownUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> WrittenFragmentInfo::Builder::disownUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool WrittenFragmentInfo::Reader::hasTimestampRange() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool WrittenFragmentInfo::Builder::hasTimestampRange() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader -WrittenFragmentInfo::Reader::getTimestampRange() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -WrittenFragmentInfo::Builder::getTimestampRange() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void WrittenFragmentInfo::Builder::setTimestampRange( - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline void WrittenFragmentInfo::Builder::setTimestampRange( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder -WrittenFragmentInfo::Builder::initTimestampRange(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader WrittenFragmentInfo::Reader::getTimestampRange() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder WrittenFragmentInfo::Builder::getTimestampRange() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void WrittenFragmentInfo::Builder::setTimestampRange( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline void WrittenFragmentInfo::Builder::setTimestampRange(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder WrittenFragmentInfo::Builder::initTimestampRange(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void WrittenFragmentInfo::Builder::adoptTimestampRange( - ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& - value) { - ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> -WrittenFragmentInfo::Builder::disownTimestampRange() { - return ::capnp::_::PointerHelpers< - ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> WrittenFragmentInfo::Builder::disownTimestampRange() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool BufferedChunk::Reader::hasUri() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool BufferedChunk::Builder::hasUri() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader BufferedChunk::Reader::getUri() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader BufferedChunk::Reader::getUri() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder BufferedChunk::Builder::getUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder BufferedChunk::Builder::getUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void BufferedChunk::Builder::setUri(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void BufferedChunk::Builder::setUri( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder BufferedChunk::Builder::initUri( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder BufferedChunk::Builder::initUri(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void BufferedChunk::Builder::adoptUri( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> BufferedChunk::Builder::disownUri() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> BufferedChunk::Builder::disownUri() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t BufferedChunk::Reader::getSize() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t BufferedChunk::Reader::getSize() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t BufferedChunk::Builder::getSize() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t BufferedChunk::Builder::getSize() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void BufferedChunk::Builder::setSize(::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void BufferedChunk::Builder::setSize( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool ArrayDeleteFragmentsListRequest::Reader::hasConfig() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ArrayDeleteFragmentsListRequest::Builder::hasConfig() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader -ArrayDeleteFragmentsListRequest::Reader::getConfig() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader ArrayDeleteFragmentsListRequest::Reader::getConfig() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -ArrayDeleteFragmentsListRequest::Builder::getConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayDeleteFragmentsListRequest::Builder::getConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline -ArrayDeleteFragmentsListRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline ArrayDeleteFragmentsListRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void ArrayDeleteFragmentsListRequest::Builder::setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void ArrayDeleteFragmentsListRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -ArrayDeleteFragmentsListRequest::Builder::initConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayDeleteFragmentsListRequest::Builder::initConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void ArrayDeleteFragmentsListRequest::Builder::adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> -ArrayDeleteFragmentsListRequest::Builder::disownConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> ArrayDeleteFragmentsListRequest::Builder::disownConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ArrayDeleteFragmentsListRequest::Reader::hasEntries() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool ArrayDeleteFragmentsListRequest::Builder::hasEntries() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -ArrayDeleteFragmentsListRequest::Reader::getEntries() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDeleteFragmentsListRequest::Builder::getEntries() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void ArrayDeleteFragmentsListRequest::Builder::setEntries( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline void ArrayDeleteFragmentsListRequest::Builder::setEntries( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayDeleteFragmentsListRequest::Builder::initEntries(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDeleteFragmentsListRequest::Reader::getEntries() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDeleteFragmentsListRequest::Builder::getEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void ArrayDeleteFragmentsListRequest::Builder::setEntries( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline void ArrayDeleteFragmentsListRequest::Builder::setEntries(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDeleteFragmentsListRequest::Builder::initEntries(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void ArrayDeleteFragmentsListRequest::Builder::adoptEntries( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -ArrayDeleteFragmentsListRequest::Builder::disownEntries() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDeleteFragmentsListRequest::Builder::disownEntries() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool ArrayDeleteFragmentsTimestampsRequest::Reader::hasConfig() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ArrayDeleteFragmentsTimestampsRequest::Builder::hasConfig() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader -ArrayDeleteFragmentsTimestampsRequest::Reader::getConfig() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader ArrayDeleteFragmentsTimestampsRequest::Reader::getConfig() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -ArrayDeleteFragmentsTimestampsRequest::Builder::getConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayDeleteFragmentsTimestampsRequest::Builder::getConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline -ArrayDeleteFragmentsTimestampsRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline ArrayDeleteFragmentsTimestampsRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void ArrayDeleteFragmentsTimestampsRequest::Builder::setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void ArrayDeleteFragmentsTimestampsRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -ArrayDeleteFragmentsTimestampsRequest::Builder::initConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayDeleteFragmentsTimestampsRequest::Builder::initConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void ArrayDeleteFragmentsTimestampsRequest::Builder::adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> -ArrayDeleteFragmentsTimestampsRequest::Builder::disownConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> ArrayDeleteFragmentsTimestampsRequest::Builder::disownConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t -ArrayDeleteFragmentsTimestampsRequest::Reader::getStartTimestamp() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t ArrayDeleteFragmentsTimestampsRequest::Reader::getStartTimestamp() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t -ArrayDeleteFragmentsTimestampsRequest::Builder::getStartTimestamp() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t ArrayDeleteFragmentsTimestampsRequest::Builder::getStartTimestamp() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ArrayDeleteFragmentsTimestampsRequest::Builder::setStartTimestamp( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void ArrayDeleteFragmentsTimestampsRequest::Builder::setStartTimestamp( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t -ArrayDeleteFragmentsTimestampsRequest::Reader::getEndTimestamp() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t ArrayDeleteFragmentsTimestampsRequest::Reader::getEndTimestamp() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t -ArrayDeleteFragmentsTimestampsRequest::Builder::getEndTimestamp() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t ArrayDeleteFragmentsTimestampsRequest::Builder::getEndTimestamp() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void ArrayDeleteFragmentsTimestampsRequest::Builder::setEndTimestamp( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void ArrayDeleteFragmentsTimestampsRequest::Builder::setEndTimestamp( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool ArrayConsolidationRequest::Reader::hasConfig() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ArrayConsolidationRequest::Builder::hasConfig() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader -ArrayConsolidationRequest::Reader::getConfig() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader ArrayConsolidationRequest::Reader::getConfig() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -ArrayConsolidationRequest::Builder::getConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayConsolidationRequest::Builder::getConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline -ArrayConsolidationRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline ArrayConsolidationRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void ArrayConsolidationRequest::Builder::setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void ArrayConsolidationRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -ArrayConsolidationRequest::Builder::initConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayConsolidationRequest::Builder::initConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void ArrayConsolidationRequest::Builder::adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> -ArrayConsolidationRequest::Builder::disownConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> ArrayConsolidationRequest::Builder::disownConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ArrayConsolidationRequest::Reader::hasFragments() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool ArrayConsolidationRequest::Builder::hasFragments() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -ArrayConsolidationRequest::Reader::getFragments() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayConsolidationRequest::Builder::getFragments() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void ArrayConsolidationRequest::Builder::setFragments( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline void ArrayConsolidationRequest::Builder::setFragments( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -ArrayConsolidationRequest::Builder::initFragments(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayConsolidationRequest::Reader::getFragments() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayConsolidationRequest::Builder::getFragments() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void ArrayConsolidationRequest::Builder::setFragments( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline void ArrayConsolidationRequest::Builder::setFragments(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayConsolidationRequest::Builder::initFragments(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void ArrayConsolidationRequest::Builder::adoptFragments( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -ArrayConsolidationRequest::Builder::disownFragments() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayConsolidationRequest::Builder::disownFragments() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool ArrayVacuumRequest::Reader::hasConfig() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ArrayVacuumRequest::Builder::hasConfig() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader -ArrayVacuumRequest::Reader::getConfig() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader ArrayVacuumRequest::Reader::getConfig() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -ArrayVacuumRequest::Builder::getConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayVacuumRequest::Builder::getConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline -ArrayVacuumRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline ArrayVacuumRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void ArrayVacuumRequest::Builder::setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void ArrayVacuumRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -ArrayVacuumRequest::Builder::initConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayVacuumRequest::Builder::initConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void ArrayVacuumRequest::Builder::adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> -ArrayVacuumRequest::Builder::disownConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> ArrayVacuumRequest::Builder::disownConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool LoadEnumerationsRequest::Reader::hasConfig() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool LoadEnumerationsRequest::Builder::hasConfig() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader -LoadEnumerationsRequest::Reader::getConfig() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader LoadEnumerationsRequest::Reader::getConfig() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -LoadEnumerationsRequest::Builder::getConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder LoadEnumerationsRequest::Builder::getConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline -LoadEnumerationsRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline LoadEnumerationsRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void LoadEnumerationsRequest::Builder::setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void LoadEnumerationsRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -LoadEnumerationsRequest::Builder::initConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder LoadEnumerationsRequest::Builder::initConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void LoadEnumerationsRequest::Builder::adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> -LoadEnumerationsRequest::Builder::disownConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> LoadEnumerationsRequest::Builder::disownConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool LoadEnumerationsRequest::Reader::hasEnumerations() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool LoadEnumerationsRequest::Builder::hasEnumerations() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -LoadEnumerationsRequest::Reader::getEnumerations() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -LoadEnumerationsRequest::Builder::getEnumerations() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void LoadEnumerationsRequest::Builder::setEnumerations( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline void LoadEnumerationsRequest::Builder::setEnumerations( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -LoadEnumerationsRequest::Builder::initEnumerations(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader LoadEnumerationsRequest::Reader::getEnumerations() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder LoadEnumerationsRequest::Builder::getEnumerations() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void LoadEnumerationsRequest::Builder::setEnumerations( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline void LoadEnumerationsRequest::Builder::setEnumerations(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder LoadEnumerationsRequest::Builder::initEnumerations(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void LoadEnumerationsRequest::Builder::adoptEnumerations( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -LoadEnumerationsRequest::Builder::disownEnumerations() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> LoadEnumerationsRequest::Builder::disownEnumerations() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool LoadEnumerationsResponse::Reader::hasEnumerations() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool LoadEnumerationsResponse::Builder::hasEnumerations() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader -LoadEnumerationsResponse::Reader::getEnumerations() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder -LoadEnumerationsResponse::Builder::getEnumerations() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void LoadEnumerationsResponse::Builder::setEnumerations( - ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>::Builder -LoadEnumerationsResponse::Builder::initEnumerations(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader LoadEnumerationsResponse::Reader::getEnumerations() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder LoadEnumerationsResponse::Builder::getEnumerations() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void LoadEnumerationsResponse::Builder::setEnumerations( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder LoadEnumerationsResponse::Builder::initEnumerations(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void LoadEnumerationsResponse::Builder::adoptEnumerations( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>> -LoadEnumerationsResponse::Builder::disownEnumerations() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Enumeration, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> LoadEnumerationsResponse::Builder::disownEnumerations() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool LoadEnumerationsResponse::Reader::hasAllEnumerations() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool LoadEnumerationsResponse::Builder::hasAllEnumerations() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::MapEnumeration::Reader -LoadEnumerationsResponse::Reader::getAllEnumerations() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::MapEnumeration>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapEnumeration::Reader LoadEnumerationsResponse::Reader::getAllEnumerations() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapEnumeration>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::MapEnumeration::Builder -LoadEnumerationsResponse::Builder::getAllEnumerations() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::MapEnumeration>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapEnumeration::Builder LoadEnumerationsResponse::Builder::getAllEnumerations() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapEnumeration>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::MapEnumeration::Pipeline -LoadEnumerationsResponse::Pipeline::getAllEnumerations() { - return ::tiledb::sm::serialization::capnp::MapEnumeration::Pipeline( - _typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::MapEnumeration::Pipeline LoadEnumerationsResponse::Pipeline::getAllEnumerations() { + return ::tiledb::sm::serialization::capnp::MapEnumeration::Pipeline(_typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void LoadEnumerationsResponse::Builder::setAllEnumerations( - ::tiledb::sm::serialization::capnp::MapEnumeration::Reader value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::MapEnumeration>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void LoadEnumerationsResponse::Builder::setAllEnumerations( ::tiledb::sm::serialization::capnp::MapEnumeration::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapEnumeration>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::MapEnumeration::Builder -LoadEnumerationsResponse::Builder::initAllEnumerations() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::MapEnumeration>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapEnumeration::Builder LoadEnumerationsResponse::Builder::initAllEnumerations() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapEnumeration>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void LoadEnumerationsResponse::Builder::adoptAllEnumerations( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapEnumeration>&& - value) { - ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::MapEnumeration>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapEnumeration>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapEnumeration>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapEnumeration> -LoadEnumerationsResponse::Builder::disownAllEnumerations() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::MapEnumeration>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapEnumeration> LoadEnumerationsResponse::Builder::disownAllEnumerations() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapEnumeration>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool LoadArraySchemaRequest::Reader::hasConfig() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool LoadArraySchemaRequest::Builder::hasConfig() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader -LoadArraySchemaRequest::Reader::getConfig() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader LoadArraySchemaRequest::Reader::getConfig() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -LoadArraySchemaRequest::Builder::getConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder LoadArraySchemaRequest::Builder::getConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline -LoadArraySchemaRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline LoadArraySchemaRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void LoadArraySchemaRequest::Builder::setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void LoadArraySchemaRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -LoadArraySchemaRequest::Builder::initConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder LoadArraySchemaRequest::Builder::initConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void LoadArraySchemaRequest::Builder::adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> -LoadArraySchemaRequest::Builder::disownConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> LoadArraySchemaRequest::Builder::disownConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool LoadArraySchemaRequest::Reader::getIncludeEnumerations() const { - return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool LoadArraySchemaRequest::Builder::getIncludeEnumerations() { - return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void LoadArraySchemaRequest::Builder::setIncludeEnumerations( - bool value) { - _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +inline void LoadArraySchemaRequest::Builder::setIncludeEnumerations(bool value) { + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool LoadArraySchemaResponse::Reader::hasSchema() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool LoadArraySchemaResponse::Builder::hasSchema() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader -LoadArraySchemaResponse::Reader::getSchema() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader LoadArraySchemaResponse::Reader::getSchema() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder -LoadArraySchemaResponse::Builder::getSchema() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder LoadArraySchemaResponse::Builder::getSchema() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline -LoadArraySchemaResponse::Pipeline::getSchema() { - return ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline LoadArraySchemaResponse::Pipeline::getSchema() { + return ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void LoadArraySchemaResponse::Builder::setSchema( - ::tiledb::sm::serialization::capnp::ArraySchema::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void LoadArraySchemaResponse::Builder::setSchema( ::tiledb::sm::serialization::capnp::ArraySchema::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder -LoadArraySchemaResponse::Builder::initSchema() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder LoadArraySchemaResponse::Builder::initSchema() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void LoadArraySchemaResponse::Builder::adoptSchema( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema> -LoadArraySchemaResponse::Builder::disownSchema() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema> LoadArraySchemaResponse::Builder::disownSchema() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool LoadArraySchemaResponse::Reader::hasArraySchemasAll() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool LoadArraySchemaResponse::Builder::hasArraySchemasAll() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::tiledb::sm::serialization::capnp:: - Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader - LoadArraySchemaResponse::Reader::getArraySchemasAll() const { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - get(_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp:: - Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder - LoadArraySchemaResponse::Builder::getArraySchemasAll() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - get(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline -LoadArraySchemaResponse::Pipeline::getArraySchemasAll() { - return ::tiledb::sm::serialization::capnp:: - Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>:: - Pipeline(_typeless.getPointerField(1)); -} -#endif // !CAPNP_LITE -inline void LoadArraySchemaResponse::Builder::setArraySchemasAll( - ::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::tiledb::sm::serialization::capnp:: - Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder - LoadArraySchemaResponse::Builder::initArraySchemasAll() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader LoadArraySchemaResponse::Reader::getArraySchemasAll() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder LoadArraySchemaResponse::Builder::getArraySchemasAll() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline LoadArraySchemaResponse::Pipeline::getArraySchemasAll() { + return ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void LoadArraySchemaResponse::Builder::setArraySchemasAll( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder LoadArraySchemaResponse::Builder::initArraySchemasAll() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void LoadArraySchemaResponse::Builder::adoptArraySchemasAll( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>> -LoadArraySchemaResponse::Builder::disownArraySchemasAll() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< - ::capnp::Text, - ::tiledb::sm::serialization::capnp::ArraySchema>>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>> LoadArraySchemaResponse::Builder::disownArraySchemasAll() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool QueryPlanRequest::Reader::hasConfig() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool QueryPlanRequest::Builder::hasConfig() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader -QueryPlanRequest::Reader::getConfig() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader QueryPlanRequest::Reader::getConfig() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -QueryPlanRequest::Builder::getConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder QueryPlanRequest::Builder::getConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline -QueryPlanRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline QueryPlanRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void QueryPlanRequest::Builder::setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void QueryPlanRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -QueryPlanRequest::Builder::initConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder QueryPlanRequest::Builder::initConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void QueryPlanRequest::Builder::adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> -QueryPlanRequest::Builder::disownConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> QueryPlanRequest::Builder::disownConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool QueryPlanRequest::Reader::hasQuery() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool QueryPlanRequest::Builder::hasQuery() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Query::Reader -QueryPlanRequest::Reader::getQuery() const { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Query>:: - get(_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Query::Reader QueryPlanRequest::Reader::getQuery() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Query>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Query::Builder -QueryPlanRequest::Builder::getQuery() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Query>:: - get(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Query::Builder QueryPlanRequest::Builder::getQuery() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Query>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Query::Pipeline -QueryPlanRequest::Pipeline::getQuery() { - return ::tiledb::sm::serialization::capnp::Query::Pipeline( - _typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::Query::Pipeline QueryPlanRequest::Pipeline::getQuery() { + return ::tiledb::sm::serialization::capnp::Query::Pipeline(_typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void QueryPlanRequest::Builder::setQuery( - ::tiledb::sm::serialization::capnp::Query::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Query>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void QueryPlanRequest::Builder::setQuery( ::tiledb::sm::serialization::capnp::Query::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Query>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Query::Builder -QueryPlanRequest::Builder::initQuery() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Query>:: - init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Query::Builder QueryPlanRequest::Builder::initQuery() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Query>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void QueryPlanRequest::Builder::adoptQuery( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Query>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Query>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Query>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Query>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Query> -QueryPlanRequest::Builder::disownQuery() { - return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Query>:: - disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Query> QueryPlanRequest::Builder::disownQuery() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Query>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool QueryPlanResponse::Reader::hasQueryLayout() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool QueryPlanResponse::Builder::hasQueryLayout() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader QueryPlanResponse::Reader::getQueryLayout() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader QueryPlanResponse::Reader::getQueryLayout() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder QueryPlanResponse::Builder::getQueryLayout() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder QueryPlanResponse::Builder::getQueryLayout() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void QueryPlanResponse::Builder::setQueryLayout( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void QueryPlanResponse::Builder::setQueryLayout( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder QueryPlanResponse::Builder::initQueryLayout( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder QueryPlanResponse::Builder::initQueryLayout(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void QueryPlanResponse::Builder::adoptQueryLayout( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -QueryPlanResponse::Builder::disownQueryLayout() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> QueryPlanResponse::Builder::disownQueryLayout() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool QueryPlanResponse::Reader::hasStrategyName() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool QueryPlanResponse::Builder::hasStrategyName() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::Text::Reader QueryPlanResponse::Reader::getStrategyName() - const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder QueryPlanResponse::Builder::getStrategyName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void QueryPlanResponse::Builder::setStrategyName( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); -} -inline ::capnp::Text::Builder QueryPlanResponse::Builder::initStrategyName( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader QueryPlanResponse::Reader::getStrategyName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder QueryPlanResponse::Builder::getStrategyName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void QueryPlanResponse::Builder::setStrategyName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder QueryPlanResponse::Builder::initStrategyName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void QueryPlanResponse::Builder::adoptStrategyName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -QueryPlanResponse::Builder::disownStrategyName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> QueryPlanResponse::Builder::disownStrategyName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool QueryPlanResponse::Reader::hasArrayType() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool QueryPlanResponse::Builder::hasArrayType() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader QueryPlanResponse::Reader::getArrayType() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader QueryPlanResponse::Reader::getArrayType() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder QueryPlanResponse::Builder::getArrayType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder QueryPlanResponse::Builder::getArrayType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void QueryPlanResponse::Builder::setArrayType( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void QueryPlanResponse::Builder::setArrayType( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder QueryPlanResponse::Builder::initArrayType( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder QueryPlanResponse::Builder::initArrayType(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void QueryPlanResponse::Builder::adoptArrayType( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -QueryPlanResponse::Builder::disownArrayType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> QueryPlanResponse::Builder::disownArrayType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool QueryPlanResponse::Reader::hasAttributeNames() const { - return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); } inline bool QueryPlanResponse::Builder::hasAttributeNames() { - return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -QueryPlanResponse::Reader::getAttributeNames() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -QueryPlanResponse::Builder::getAttributeNames() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline void QueryPlanResponse::Builder::setAttributeNames( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline void QueryPlanResponse::Builder::setAttributeNames( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -QueryPlanResponse::Builder::initAttributeNames(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader QueryPlanResponse::Reader::getAttributeNames() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder QueryPlanResponse::Builder::getAttributeNames() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void QueryPlanResponse::Builder::setAttributeNames( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline void QueryPlanResponse::Builder::setAttributeNames(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder QueryPlanResponse::Builder::initAttributeNames(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), size); } inline void QueryPlanResponse::Builder::adoptAttributeNames( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -QueryPlanResponse::Builder::disownAttributeNames() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> QueryPlanResponse::Builder::disownAttributeNames() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool QueryPlanResponse::Reader::hasDimensionNames() const { - return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); } inline bool QueryPlanResponse::Builder::hasDimensionNames() { - return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader -QueryPlanResponse::Reader::getDimensionNames() const { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -QueryPlanResponse::Builder::getDimensionNames() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline void QueryPlanResponse::Builder::setDimensionNames( - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); -} -inline void QueryPlanResponse::Builder::setDimensionNames( - ::kj::ArrayPtr value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder -QueryPlanResponse::Builder::initDimensionNames(unsigned int size) { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader QueryPlanResponse::Reader::getDimensionNames() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder QueryPlanResponse::Builder::getDimensionNames() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void QueryPlanResponse::Builder::setDimensionNames( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline void QueryPlanResponse::Builder::setDimensionNames(::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder QueryPlanResponse::Builder::initDimensionNames(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), size); } inline void QueryPlanResponse::Builder::adoptDimensionNames( - ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& - value) { - ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> -QueryPlanResponse::Builder::disownDimensionNames() { - return ::capnp::_:: - PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( - _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> QueryPlanResponse::Builder::disownDimensionNames() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( + ::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool ConsolidationPlanRequest::Reader::hasConfig() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ConsolidationPlanRequest::Builder::hasConfig() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader -ConsolidationPlanRequest::Reader::getConfig() const { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader ConsolidationPlanRequest::Reader::getConfig() const { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -ConsolidationPlanRequest::Builder::getConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder ConsolidationPlanRequest::Builder::getConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline -ConsolidationPlanRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline( - _typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline ConsolidationPlanRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void ConsolidationPlanRequest::Builder::setConfig( - ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void ConsolidationPlanRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder -ConsolidationPlanRequest::Builder::initConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder ConsolidationPlanRequest::Builder::initConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void ConsolidationPlanRequest::Builder::adoptConfig( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> -ConsolidationPlanRequest::Builder::disownConfig() { - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> ConsolidationPlanRequest::Builder::disownConfig() { + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t ConsolidationPlanRequest::Reader::getFragmentSize() const { - return _reader.getDataField<::uint64_t>( +inline ::uint64_t ConsolidationPlanRequest::Reader::getFragmentSize() const { + return _reader.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t ConsolidationPlanRequest::Builder::getFragmentSize() { - return _builder.getDataField<::uint64_t>( +inline ::uint64_t ConsolidationPlanRequest::Builder::getFragmentSize() { + return _builder.getDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ConsolidationPlanRequest::Builder::setFragmentSize( - ::uint64_t value) { - _builder.setDataField<::uint64_t>( +inline void ConsolidationPlanRequest::Builder::setFragmentSize( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool ConsolidationPlanResponse::Reader::hasFragmentUrisPerNode() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool ConsolidationPlanResponse::Builder::hasFragmentUrisPerNode() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>::Reader -ConsolidationPlanResponse::Reader::getFragmentUrisPerNode() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>::Builder -ConsolidationPlanResponse::Builder::getFragmentUrisPerNode() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void ConsolidationPlanResponse::Builder::setFragmentUrisPerNode( - ::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline void ConsolidationPlanResponse::Builder::setFragmentUrisPerNode( - ::kj::ArrayPtr< - const ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader> - value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>::Builder -ConsolidationPlanResponse::Builder::initFragmentUrisPerNode(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Reader ConsolidationPlanResponse::Reader::getFragmentUrisPerNode() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Builder ConsolidationPlanResponse::Builder::getFragmentUrisPerNode() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void ConsolidationPlanResponse::Builder::setFragmentUrisPerNode( ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline void ConsolidationPlanResponse::Builder::setFragmentUrisPerNode(::kj::ArrayPtr::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Builder ConsolidationPlanResponse::Builder::initFragmentUrisPerNode(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void ConsolidationPlanResponse::Builder::adoptFragmentUrisPerNode( - ::capnp::Orphan<::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>> -ConsolidationPlanResponse::Builder::disownFragmentUrisPerNode() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, - ::capnp::Kind::LIST>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>> ConsolidationPlanResponse::Builder::disownFragmentUrisPerNode() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool QueryChannel::Reader::getDefault() const { - return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool QueryChannel::Builder::getDefault() { - return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void QueryChannel::Builder::setDefault(bool value) { - _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool QueryChannel::Reader::hasAggregates() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool QueryChannel::Builder::hasAggregates() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>::Reader -QueryChannel::Reader::getAggregates() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>::Builder -QueryChannel::Builder::getAggregates() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void QueryChannel::Builder::setAggregates( - ::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>::Builder -QueryChannel::Builder::initAggregates(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>::Reader QueryChannel::Reader::getAggregates() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>::Builder QueryChannel::Builder::getAggregates() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void QueryChannel::Builder::setAggregates( ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>::Builder QueryChannel::Builder::initAggregates(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void QueryChannel::Builder::adoptAggregates( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>> -QueryChannel::Builder::disownAggregates() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::Aggregate, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>> QueryChannel::Builder::disownAggregates() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Aggregate::Reader::hasOutputFieldName() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool Aggregate::Builder::hasOutputFieldName() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Aggregate::Reader::getOutputFieldName() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Aggregate::Reader::getOutputFieldName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Aggregate::Builder::getOutputFieldName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Aggregate::Builder::getOutputFieldName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Aggregate::Builder::setOutputFieldName( - ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void Aggregate::Builder::setOutputFieldName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Aggregate::Builder::initOutputFieldName( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Aggregate::Builder::initOutputFieldName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void Aggregate::Builder::adoptOutputFieldName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -Aggregate::Builder::disownOutputFieldName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Aggregate::Builder::disownOutputFieldName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Aggregate::Reader::hasInputFieldName() const { - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool Aggregate::Builder::hasInputFieldName() { - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Aggregate::Reader::getInputFieldName() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Aggregate::Reader::getInputFieldName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Aggregate::Builder::getInputFieldName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Aggregate::Builder::getInputFieldName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void Aggregate::Builder::setInputFieldName(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); +inline void Aggregate::Builder::setInputFieldName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Aggregate::Builder::initInputFieldName( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Aggregate::Builder::initInputFieldName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), size); } inline void Aggregate::Builder::adoptInputFieldName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> -Aggregate::Builder::disownInputFieldName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Aggregate::Builder::disownInputFieldName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Aggregate::Reader::hasName() const { - return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } inline bool Aggregate::Builder::hasName() { - return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader Aggregate::Reader::getName() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Aggregate::Reader::getName() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Aggregate::Builder::getName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Aggregate::Builder::getName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void Aggregate::Builder::setName(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - value); +inline void Aggregate::Builder::setName( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder Aggregate::Builder::initName(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder Aggregate::Builder::initName(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), size); } inline void Aggregate::Builder::adoptName( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> Aggregate::Builder::disownName() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> Aggregate::Builder::disownName() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Which -CurrentDomain::Reader::which() const { - return _reader.getDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Which CurrentDomain::Reader::which() const { + return _reader.getDataField( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Which -CurrentDomain::Builder::which() { +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Which CurrentDomain::Builder::which() { return _builder.getDataField( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint32_t CurrentDomain::Reader::getVersion() const { - return _reader.getDataField<::uint32_t>( +inline ::uint32_t CurrentDomain::Reader::getVersion() const { + return _reader.getDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint32_t CurrentDomain::Builder::getVersion() { - return _builder.getDataField<::uint32_t>( +inline ::uint32_t CurrentDomain::Builder::getVersion() { + return _builder.getDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void CurrentDomain::Builder::setVersion(::uint32_t value) { - _builder.setDataField<::uint32_t>( +inline void CurrentDomain::Builder::setVersion( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool CurrentDomain::Reader::hasType() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool CurrentDomain::Builder::hasType() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } -inline ::capnp::Text::Reader CurrentDomain::Reader::getType() const { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader CurrentDomain::Reader::getType() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder CurrentDomain::Builder::getType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::get( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder CurrentDomain::Builder::getType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void CurrentDomain::Builder::setType(::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers<::capnp::Text>::set( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); +inline void CurrentDomain::Builder::setType( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); } -inline ::capnp::Text::Builder CurrentDomain::Builder::initType( - unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::Text>::init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); +inline ::capnp::Text::Builder CurrentDomain::Builder::initType(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void CurrentDomain::Builder::adoptType( - ::capnp::Orphan<::capnp::Text>&& value) { - ::capnp::_::PointerHelpers<::capnp::Text>::adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::capnp::Text> CurrentDomain::Builder::disownType() { - return ::capnp::_::PointerHelpers<::capnp::Text>::disown( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::capnp::Text> CurrentDomain::Builder::disownType() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool CurrentDomain::Reader::isEmptyCurrentDomain() const { @@ -34497,26 +25421,23 @@ inline bool CurrentDomain::Reader::isEmptyCurrentDomain() const { inline bool CurrentDomain::Builder::isEmptyCurrentDomain() { return which() == CurrentDomain::EMPTY_CURRENT_DOMAIN; } -inline ::capnp::Void CurrentDomain::Reader::getEmptyCurrentDomain() const { - KJ_IREQUIRE( - (which() == CurrentDomain::EMPTY_CURRENT_DOMAIN), - "Must check which() before get()ing a union member."); - return _reader.getDataField<::capnp::Void>( +inline ::capnp::Void CurrentDomain::Reader::getEmptyCurrentDomain() const { + KJ_IREQUIRE((which() == CurrentDomain::EMPTY_CURRENT_DOMAIN), + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::capnp::Void>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::capnp::Void CurrentDomain::Builder::getEmptyCurrentDomain() { - KJ_IREQUIRE( - (which() == CurrentDomain::EMPTY_CURRENT_DOMAIN), - "Must check which() before get()ing a union member."); - return _builder.getDataField<::capnp::Void>( +inline ::capnp::Void CurrentDomain::Builder::getEmptyCurrentDomain() { + KJ_IREQUIRE((which() == CurrentDomain::EMPTY_CURRENT_DOMAIN), + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::capnp::Void>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void CurrentDomain::Builder::setEmptyCurrentDomain(::capnp::Void value) { +inline void CurrentDomain::Builder::setEmptyCurrentDomain( ::capnp::Void value) { _builder.setDataField( - ::capnp::bounded<2>() * ::capnp::ELEMENTS, - CurrentDomain::EMPTY_CURRENT_DOMAIN); - _builder.setDataField<::capnp::Void>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, CurrentDomain::EMPTY_CURRENT_DOMAIN); + _builder.setDataField< ::capnp::Void>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } @@ -34527,164 +25448,105 @@ inline bool CurrentDomain::Builder::isNdRectangle() { return which() == CurrentDomain::ND_RECTANGLE; } inline bool CurrentDomain::Reader::hasNdRectangle() const { - if (which() != CurrentDomain::ND_RECTANGLE) - return false; - return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); + if (which() != CurrentDomain::ND_RECTANGLE) return false; + return !_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); } inline bool CurrentDomain::Builder::hasNdRectangle() { - if (which() != CurrentDomain::ND_RECTANGLE) - return false; - return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) - .isNull(); -} -inline ::tiledb::sm::serialization::capnp::NDRectangle::Reader -CurrentDomain::Reader::getNdRectangle() const { - KJ_IREQUIRE( - (which() == CurrentDomain::ND_RECTANGLE), - "Must check which() before get()ing a union member."); - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::NDRectangle>::get( - _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::NDRectangle::Builder -CurrentDomain::Builder::getNdRectangle() { - KJ_IREQUIRE( - (which() == CurrentDomain::ND_RECTANGLE), - "Must check which() before get()ing a union member."); - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::NDRectangle>::get( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void CurrentDomain::Builder::setNdRectangle( - ::tiledb::sm::serialization::capnp::NDRectangle::Reader value) { + if (which() != CurrentDomain::ND_RECTANGLE) return false; + return !_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); +} +inline ::tiledb::sm::serialization::capnp::NDRectangle::Reader CurrentDomain::Reader::getNdRectangle() const { + KJ_IREQUIRE((which() == CurrentDomain::ND_RECTANGLE), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NDRectangle>::get(_reader.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::NDRectangle::Builder CurrentDomain::Builder::getNdRectangle() { + KJ_IREQUIRE((which() == CurrentDomain::ND_RECTANGLE), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NDRectangle>::get(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void CurrentDomain::Builder::setNdRectangle( ::tiledb::sm::serialization::capnp::NDRectangle::Reader value) { _builder.setDataField( ::capnp::bounded<2>() * ::capnp::ELEMENTS, CurrentDomain::ND_RECTANGLE); - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::NDRectangle>:: - set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - value); + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NDRectangle>::set(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), value); } -inline ::tiledb::sm::serialization::capnp::NDRectangle::Builder -CurrentDomain::Builder::initNdRectangle() { +inline ::tiledb::sm::serialization::capnp::NDRectangle::Builder CurrentDomain::Builder::initNdRectangle() { _builder.setDataField( ::capnp::bounded<2>() * ::capnp::ELEMENTS, CurrentDomain::ND_RECTANGLE); - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::NDRectangle>::init( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NDRectangle>::init(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void CurrentDomain::Builder::adoptNdRectangle( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::NDRectangle>&& value) { + ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NDRectangle>&& value) { _builder.setDataField( ::capnp::bounded<2>() * ::capnp::ELEMENTS, CurrentDomain::ND_RECTANGLE); - ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::NDRectangle>:: - adopt( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), - kj::mv(value)); + ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NDRectangle>::adopt(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); } -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::NDRectangle> -CurrentDomain::Builder::disownNdRectangle() { - KJ_IREQUIRE( - (which() == CurrentDomain::ND_RECTANGLE), - "Must check which() before get()ing a union member."); - return ::capnp::_:: - PointerHelpers<::tiledb::sm::serialization::capnp::NDRectangle>::disown( - _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NDRectangle> CurrentDomain::Builder::disownNdRectangle() { + KJ_IREQUIRE((which() == CurrentDomain::ND_RECTANGLE), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NDRectangle>::disown(_builder.getPointerField( + ::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool NDRectangle::Reader::hasNdranges() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); + return !_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); } inline bool NDRectangle::Builder::hasNdranges() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>::Reader -NDRectangle::Reader::getNdranges() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>::Builder -NDRectangle::Builder::getNdranges() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void NDRectangle::Builder::setNdranges( - ::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>::Builder -NDRectangle::Builder::initNdranges(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); + return !_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Reader NDRectangle::Reader::getNdranges() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Builder NDRectangle::Builder::getNdranges() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void NDRectangle::Builder::setNdranges( ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Builder NDRectangle::Builder::initNdranges(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), size); } inline void NDRectangle::Builder::adoptNdranges( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>> -NDRectangle::Builder::disownNdranges() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::SubarrayRanges, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} - -inline ::tiledb::sm::serialization::capnp::ObjectType -ObjectInfoResponse::Reader::getObjectType() const { - return _reader.getDataField<::tiledb::sm::serialization::capnp::ObjectType>( + ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>> NDRectangle::Builder::disownNdranges() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( + ::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline ::tiledb::sm::serialization::capnp::ObjectType ObjectInfoResponse::Reader::getObjectType() const { + return _reader.getDataField< ::tiledb::sm::serialization::capnp::ObjectType>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::tiledb::sm::serialization::capnp::ObjectType -ObjectInfoResponse::Builder::getObjectType() { - return _builder.getDataField<::tiledb::sm::serialization::capnp::ObjectType>( +inline ::tiledb::sm::serialization::capnp::ObjectType ObjectInfoResponse::Builder::getObjectType() { + return _builder.getDataField< ::tiledb::sm::serialization::capnp::ObjectType>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ObjectInfoResponse::Builder::setObjectType( - ::tiledb::sm::serialization::capnp::ObjectType value) { - _builder.setDataField<::tiledb::sm::serialization::capnp::ObjectType>( +inline void ObjectInfoResponse::Builder::setObjectType( ::tiledb::sm::serialization::capnp::ObjectType value) { + _builder.setDataField< ::tiledb::sm::serialization::capnp::ObjectType>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -} // namespace capnp -} // namespace serialization -} // namespace sm -} // namespace tiledb +} // namespace +} // namespace +} // namespace +} // namespace CAPNP_END_HEADER + From 628e7d620f5548dc9a21e54247744d30559c9022 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 31 Dec 2024 16:21:15 -0500 Subject: [PATCH 091/228] Change config parameter to be uint64_t determining merge unit min size --- test/src/unit-capi-config.cc | 5 ++--- test/src/unit-sparse-global-order-reader.cc | 2 +- tiledb/api/c_api/config/config_api_external.h | 5 +++-- tiledb/sm/config/config.cc | 2 +- .../sm/query/readers/sparse_global_order_reader.cc | 14 +++++++++----- 5 files changed, 16 insertions(+), 12 deletions(-) diff --git a/test/src/unit-capi-config.cc b/test/src/unit-capi-config.cc index 901e8cb2314..02ec25d91d4 100644 --- a/test/src/unit-capi-config.cc +++ b/test/src/unit-capi-config.cc @@ -292,7 +292,7 @@ void check_save_to_file() { ss << "sm.partial_tile_offsets_loading false\n"; ss << "sm.query.dense.qc_coords_mode false\n"; ss << "sm.query.dense.reader refactored\n"; - ss << "sm.query.sparse_global_order.preprocess_tile_merge false\n"; + ss << "sm.query.sparse_global_order.preprocess_tile_merge 0\n"; ss << "sm.query.sparse_global_order.reader refactored\n"; ss << "sm.query.sparse_unordered_with_dups.reader refactored\n"; ss << "sm.read_range_oob warn\n"; @@ -642,8 +642,7 @@ TEST_CASE("C API: Test config iter", "[capi][config]") { all_param_values["sm.memory_budget_var"] = "10737418240"; all_param_values["sm.query.dense.qc_coords_mode"] = "false"; all_param_values["sm.query.dense.reader"] = "refactored"; - all_param_values["sm.query.sparse_global_order.preprocess_tile_merge"] = - "false"; + all_param_values["sm.query.sparse_global_order.preprocess_tile_merge"] = "0"; all_param_values["sm.query.sparse_global_order.reader"] = "refactored"; all_param_values["sm.query.sparse_unordered_with_dups.reader"] = "refactored"; all_param_values["sm.mem.consolidation.buffers_weight"] = "1"; diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 6c92eb387e1..fc90b20f7b6 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -3137,7 +3137,7 @@ TEST_CASE_METHOD( rc = tiledb_config_set( qconfig, "sm.query.sparse_global_order.preprocess_tile_merge", - "true", + "128", &error); RCCATCH_REQUIRE("" == error_if_any(rc)); rc = tiledb_query_set_config(ctx_, on_query, qconfig); diff --git a/tiledb/api/c_api/config/config_api_external.h b/tiledb/api/c_api/config/config_api_external.h index c99f6ebad60..c74cbf6d45c 100644 --- a/tiledb/api/c_api/config/config_api_external.h +++ b/tiledb/api/c_api/config/config_api_external.h @@ -259,11 +259,12 @@ TILEDB_EXPORT void tiledb_config_free(tiledb_config_t** config) TILEDB_NOEXCEPT; * **Default**: refactored * - `sm.query.sparse_global_order.preprocess_tile_merge`
* Performance configuration for sparse global order read queries. - * If `true`, prior to loading the first tiles, the reader will run + * If nonzero, prior to loading the first tiles, the reader will run * a preprocessing step to arrange tiles from all fragments in a single * globally ordered list. This is expected to improve performance when * there are many fragments or when the distribution in space of the - * tiles amongst the fragments is skewed. + * tiles amongst the fragments is skewed. The value of the parameter + * specifies the amount of work per parallel task. * **Default**: "false" * - `sm.query.sparse_unordered_with_dups.reader`
* Which reader to use for sparse unordered with dups queries. diff --git a/tiledb/sm/config/config.cc b/tiledb/sm/config/config.cc index 4c7499112f7..6a456527705 100644 --- a/tiledb/sm/config/config.cc +++ b/tiledb/sm/config/config.cc @@ -119,7 +119,7 @@ const std::string Config::SM_QUERY_DENSE_QC_COORDS_MODE = "false"; const std::string Config::SM_QUERY_DENSE_READER = "refactored"; const std::string Config::SM_QUERY_SPARSE_GLOBAL_ORDER_READER = "refactored"; const std::string Config::SM_QUERY_SPARSE_GLOBAL_ORDER_PREPROCESS_TILE_MERGE = - "false"; + "0"; const std::string Config::SM_QUERY_SPARSE_UNORDERED_WITH_DUPS_READER = "refactored"; const std::string Config::SM_MEM_MALLOC_TRIM = "true"; diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index e4e75fe476d..d4e60c02e3c 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -126,8 +126,10 @@ SparseGlobalOrderReader::SparseGlobalOrderReader( preprocess_tile_order_.enabled_ = array_schema_.cell_order() != Layout::HILBERT && - config_.get("sm.query.sparse_global_order.preprocess_tile_merge") - .value_or(false); + 0 < config_ + .get( + "sm.query.sparse_global_order.preprocess_tile_merge") + .value_or(0); preprocess_tile_order_.cursor_ = 0; if (!preprocess_tile_order_.enabled_) { @@ -515,11 +517,13 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( preprocess_tile_order_.tiles_.resize( num_result_tiles, ResultTileId{.fragment_idx_ = 0, .tile_idx_ = 0}); + const auto min_merge_items = + config_ + .get("sm.query.sparse_global_order.preprocess_tile_merge") + .value(); future.merge_options_ = { .parallel_factor = resources_.compute_tp().concurrency_level(), - .min_merge_items = - 128 // TODO: do some experiments to figure something out - }; + .min_merge_items = min_merge_items}; algorithm::ParallelMergeMemoryResources merge_resources( *query_memory_tracker_.get()); From 76325d4021b9e234642ff48c30f28deee74bb8d4 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 31 Dec 2024 16:24:00 -0500 Subject: [PATCH 092/228] Mkae FsLocal the default --- test/support/src/vfs_helpers.cc | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/support/src/vfs_helpers.cc b/test/support/src/vfs_helpers.cc index 7935f1d4253..4b447363add 100644 --- a/test/support/src/vfs_helpers.cc +++ b/test/support/src/vfs_helpers.cc @@ -66,6 +66,9 @@ std::vector> vfs_test_get_fs_vec() { &supports_gcs, &supports_rest_s3); + // some codes uses fs_vec[0] as the default, default to native filesystem + fs_vec.emplace_back(std::make_unique()); + if (supports_s3) { fs_vec.emplace_back(std::make_unique()); } @@ -91,7 +94,6 @@ std::vector> vfs_test_get_fs_vec() { } } - fs_vec.emplace_back(std::make_unique()); fs_vec.emplace_back(std::make_unique()); return fs_vec; From beb96043316b794a07a06671ba38cbc4f899fac0 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 31 Dec 2024 16:27:13 -0500 Subject: [PATCH 093/228] Formatting and comments --- test/support/src/error_helpers.h | 1 - .../readers/sparse_global_order_reader.cc | 14 +- tiledb/sm/serialization/tiledb-rest.capnp.h | 34431 ++++++++++------ 3 files changed, 21890 insertions(+), 12556 deletions(-) diff --git a/test/support/src/error_helpers.h b/test/support/src/error_helpers.h index 816079b4c0e..d9c603ead4a 100644 --- a/test/support/src/error_helpers.h +++ b/test/support/src/error_helpers.h @@ -91,4 +91,3 @@ std::string error_if_any(tiledb_ctx_t* ctx, CAPIReturn apirc) { } // namespace tiledb::test #endif - diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index d4e60c02e3c..a0db8a4639b 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -542,6 +542,8 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( } bool operator()(const ResultTileId& a, const ResultTileId& b) const { + // FIXME: this can potentially make a better global order if + // we clamp the MBR lower bounds using the subarray const RangeLowerBound a_mbr = { .mbr = fragment_metadata_[a.fragment_idx_]->mbr(a.tile_idx_)}; const RangeLowerBound b_mbr = { @@ -604,7 +606,7 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( default: stdx::unreachable(); } -} +} // namespace tiledb::sm template std::vector @@ -1204,6 +1206,8 @@ AddNextCellResult SparseGlobalOrderReader::add_next_cell_to_queue( // Skip comparison if the next one is the same fragment, // in that case we know the cells are ordered correctly if (frag_idx != next_global_order_tile.fragment_idx_) { + // FIXME: this can potentially make better slabs if we clamp + // the MBR lower bound using the subarray and/or bitmap RangeLowerBound target = {.mbr = emit_bound}; GlobalCellCmp cmp(array_schema_.domain()); @@ -1211,14 +1215,6 @@ AddNextCellResult SparseGlobalOrderReader::add_next_cell_to_queue( if (cmp(target, rc)) { // more tiles needed, out-of-order tiles is a possibility if we // continue - - // TODO: make sure we have test coverage here. - // 1) scenario where this does not guarantee progress, i.e. - // too many overlapping tiles, we can't emit anything else - // and increasing memory budget really is the only way out - // 2) scenario where this does make progress because we - // finish a tile and thus gain budget to load the next one - return AddNextCellResult::MergeBound; } } diff --git a/tiledb/sm/serialization/tiledb-rest.capnp.h b/tiledb/sm/serialization/tiledb-rest.capnp.h index 5ad64933564..d198f47750a 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp.h +++ b/tiledb/sm/serialization/tiledb-rest.capnp.h @@ -7,12 +7,13 @@ #include #ifndef CAPNP_VERSION -#error "CAPNP_VERSION is not defined, is capnp/generated-header-support.h missing?" +#error \ + "CAPNP_VERSION is not defined, is capnp/generated-header-support.h missing?" #elif CAPNP_VERSION != 1000002 -#error "Version mismatch between generated code and library headers. You must use the same version of the Cap'n Proto compiler and library." +#error \ + "Version mismatch between generated code and library headers. You must use the same version of the Cap'n Proto compiler and library." #endif - CAPNP_BEGIN_HEADER namespace capnp { @@ -118,7 +119,7 @@ CAPNP_DECLARE_SCHEMA(e193f1f45a9f102e); CAPNP_DECLARE_SCHEMA(fafb9c94c6b54ec9); CAPNP_DECLARE_SCHEMA(ce64eabcdabb02b5); CAPNP_DECLARE_SCHEMA(f3bb391da5271019); -enum class ObjectType_f3bb391da5271019: uint16_t { +enum class ObjectType_f3bb391da5271019 : uint16_t { ARRAY, GROUP, }; @@ -142,9 +143,11 @@ struct DomainArray { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(ce5904e6f9410cec, 0, 10) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -157,9 +160,11 @@ struct KV { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(e3dadf2bf211bc97, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -172,9 +177,11 @@ struct Config { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(b6c95b4b8111ad36, 0, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -187,9 +194,11 @@ struct Array { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a45730f57e0460b4, 3, 8) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -202,9 +211,11 @@ struct ArrayOpen { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(facceeafd4472c68, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -217,9 +228,11 @@ struct ArraySchema { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d71de32f98e296fe, 2, 16) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -232,9 +245,11 @@ struct DimensionLabel { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(ceff8d62d10cd1de, 2, 6) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -247,9 +262,11 @@ struct ArraySchemaEvolution { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a1b81d67548230d4, 0, 7) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -262,9 +279,11 @@ struct Attribute { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(92ad78f56de3d76a, 1, 6) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -277,9 +296,11 @@ struct Enumeration { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d00b2f19cc21b9b4, 1, 5) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -292,9 +313,11 @@ struct AttributeBufferHeader { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d20a578112fa92a2, 6, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -308,9 +331,11 @@ struct Dimension { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(95e26a84d32d8223, 2, 4) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -320,7 +345,7 @@ struct Dimension::TileExtent { class Reader; class Builder; class Pipeline; - enum Which: uint16_t { + enum Which : uint16_t { INT8, UINT8, INT16, @@ -335,9 +360,11 @@ struct Dimension::TileExtent { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a2a652536db09fa0, 2, 4) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -350,9 +377,11 @@ struct Domain { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(de030f447664754c, 0, 4) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -365,9 +394,11 @@ struct Error { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(fa787661cd3563a4, 1, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -380,9 +411,11 @@ struct FloatScaleConfig { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(fda1cb9663a55b70, 3, 0) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -395,9 +428,11 @@ struct WebpConfig { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(fd5825d8c6e74d78, 2, 0) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -411,9 +446,11 @@ struct Filter { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(e7175047415b3f97, 2, 4) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -423,7 +460,7 @@ struct Filter::Data { class Reader; class Builder; class Pipeline; - enum Which: uint16_t { + enum Which : uint16_t { TEXT, BYTES, INT8, @@ -440,9 +477,11 @@ struct Filter::Data { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(9ceaf832b3ab897f, 2, 4) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -455,13 +494,17 @@ struct FilterPipeline { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(bc4583f733eac4f5, 0, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; -template +template < + typename Key = ::capnp::AnyPointer, + typename Value = ::capnp::AnyPointer> struct Map { Map() = delete; @@ -472,13 +515,15 @@ struct Map { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(f179c194ae71718c, 0, 1) - #if !CAPNP_LITE +#if !CAPNP_LITE static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; static const ::capnp::_::RawBrandedSchema::Dependency brandDependencies[]; static const ::capnp::_::RawBrandedSchema specificBrand; - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, Key, Value>::brand(); } - #endif // !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return ::capnp::_::ChooseBrand<_capnpPrivate, Key, Value>::brand(); + } +#endif // !CAPNP_LITE }; }; @@ -492,12 +537,14 @@ struct Map::Entry { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(db5514c8aaf6faea, 0, 2) - #if !CAPNP_LITE +#if !CAPNP_LITE static const ::capnp::_::RawBrandedSchema::Scope brandScopes[]; static const ::capnp::_::RawBrandedSchema::Binding brandBindings[]; static const ::capnp::_::RawBrandedSchema specificBrand; - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return ::capnp::_::ChooseBrand<_capnpPrivate, Key, Value>::brand(); } - #endif // !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return ::capnp::_::ChooseBrand<_capnpPrivate, Key, Value>::brand(); + } +#endif // !CAPNP_LITE }; }; @@ -511,9 +558,11 @@ struct MapEnumeration { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a9d01efb4b5d8599, 0, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -526,9 +575,11 @@ struct MapEnumeration::Entry { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(ff915a194348206a, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -542,9 +593,11 @@ struct MapUInt32 { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(c6b5bb09d4611252, 0, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -557,9 +610,11 @@ struct MapUInt32::Entry { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(884e0a5f2521a5c6, 1, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -573,9 +628,11 @@ struct MapInt64 { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a83707d3ba24dd32, 0, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -588,9 +645,11 @@ struct MapInt64::Entry { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a9caccb4333a2baf, 1, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -604,9 +663,11 @@ struct MapUInt64 { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d3c5983c670e0f42, 0, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -619,9 +680,11 @@ struct MapUInt64::Entry { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(82d7452da7cd249a, 1, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -635,9 +698,11 @@ struct MapFloat64 { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(9354174d952207d2, 0, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -650,9 +715,11 @@ struct MapFloat64::Entry { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(bb80cdbc3f312934, 1, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -665,9 +732,11 @@ struct Stats { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(c7e036a11506a1a4, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -680,9 +749,11 @@ struct UnorderedWriterState { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(8bf6c1d37e748294, 1, 3) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -695,9 +766,11 @@ struct Writer { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(8ba60147a0e6735e, 1, 5) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -710,9 +783,11 @@ struct SubarrayRanges { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(86cfc12d74ed4aa0, 1, 4) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -725,9 +800,11 @@ struct LabelSubarrayRanges { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(f7aa276767b422e7, 1, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -740,9 +817,11 @@ struct Subarray { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(dba20dec138adac9, 1, 6) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -757,9 +836,11 @@ struct SubarrayPartitioner { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(ff14003c70494585, 3, 5) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -772,9 +853,11 @@ struct SubarrayPartitioner::PartitionInfo { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(f86b7bf97823250f, 3, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -787,9 +870,11 @@ struct SubarrayPartitioner::State { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(fdd9e47288724221, 2, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -802,9 +887,11 @@ struct ReadState { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(cbe1e7c13508aa2c, 1, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -817,9 +904,11 @@ struct ConditionClause { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(dac6a7f675c57409, 1, 3) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -832,9 +921,11 @@ struct ASTNode { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(afc739d5c01e6496, 1, 6) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -847,9 +938,11 @@ struct Condition { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(eaf57cb9871fc06f, 0, 3) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -862,9 +955,11 @@ struct QueryReader { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(e19754f813ccf79c, 1, 5) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -877,9 +972,11 @@ struct Delete { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d74f5fed155d316c, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -892,9 +989,11 @@ struct ResultCellSlab { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(def87cead82188e7, 4, 0) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -907,9 +1006,11 @@ struct FragmentIndex { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(c1a2d010de779de5, 2, 0) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -922,9 +1023,11 @@ struct ReadStateIndex { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(c86c77b5f6a2bf0f, 1, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -937,9 +1040,11 @@ struct PreprocessTileOrder { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(818a8600b3452aa4, 1, 0) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -952,9 +1057,11 @@ struct ReaderIndex { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(9b9a5fc7713a8692, 0, 6) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -967,9 +1074,11 @@ struct Query { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(96ba49d0f8b23ccc, 4, 17) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -982,9 +1091,11 @@ struct NonEmptyDomain { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(9df6f2a42c4e5f0b, 1, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -997,9 +1108,11 @@ struct NonEmptyDomainList { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a18264549448ece3, 0, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1012,9 +1125,11 @@ struct AttributeBufferSize { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(9be1921b07e6cd2d, 3, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1028,9 +1143,11 @@ struct ArrayMetadata { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(9737dcafdfce31bb, 0, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1043,9 +1160,11 @@ struct ArrayMetadata::MetadataEntry { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(926fe1c3b12ed651, 1, 3) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1060,9 +1179,11 @@ struct ArrayDirectory { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(9317f20ce509d918, 2, 12) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1075,9 +1196,11 @@ struct ArrayDirectory::TimestampedURI { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d9d27c082dec9e26, 2, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1090,9 +1213,11 @@ struct ArrayDirectory::DeleteAndUpdateTileLocation { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(9eb745af522d087c, 1, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1107,9 +1232,11 @@ struct EstimatedResultSize { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(8cd4e323f1feea3b, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1122,9 +1249,11 @@ struct EstimatedResultSize::ResultSize { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(92c8467685565269, 3, 0) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1137,9 +1266,11 @@ struct EstimatedResultSize::MemorySize { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(bda7916926591c22, 3, 0) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1152,9 +1283,11 @@ struct FragmentInfoRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(c95970eb9310dc9c, 0, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1167,9 +1300,11 @@ struct SingleFragmentInfo { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d42e7b38b33e3d29, 1, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1182,9 +1317,11 @@ struct FragmentInfo { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a000530ab1d17816, 0, 4) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1197,9 +1334,11 @@ struct GroupMetadata { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(838188de0fd57580, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1212,9 +1351,11 @@ struct GroupMember { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(c41bcc7e8cc58f18, 1, 3) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1228,9 +1369,11 @@ struct Group { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(dcdd20e1b79e915a, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1243,9 +1386,11 @@ struct Group::GroupDetails { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a2ea10c715b475c1, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1259,9 +1404,11 @@ struct GroupUpdate { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(c4e54a63294eddb7, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1274,9 +1421,11 @@ struct GroupUpdate::GroupUpdateDetails { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(83b01e46759bde40, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1290,9 +1439,11 @@ struct GroupCreate { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(fb7f36ad4d8ffe84, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1305,9 +1456,11 @@ struct GroupCreate::GroupCreateDetails { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d5fd459ad75e86a9, 0, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1320,9 +1473,11 @@ struct GlobalWriteState { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(c0c730b5390f4427, 1, 4) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1335,9 +1490,11 @@ struct SingleCoord { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d8bd3c0dec37b773, 0, 3) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1351,9 +1508,11 @@ struct FragmentMetadata { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(cde352fc27e7ca61, 4, 23) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1366,9 +1525,11 @@ struct FragmentMetadata::GenericTileOffsets { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(89aa8f4e88036b9e, 3, 8) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1381,9 +1542,11 @@ struct MultiPartUploadState { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(d492b6734d5e3bf5, 1, 4) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1396,9 +1559,11 @@ struct CompletedPart { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(bde8ebd7b13d8625, 1, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1411,9 +1576,11 @@ struct WrittenFragmentInfo { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(a736c51d292ca752, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1426,9 +1593,11 @@ struct BufferedChunk { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(cd8abc9dabc4b03f, 1, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1441,9 +1610,11 @@ struct ArrayDeleteFragmentsListRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(cfea684b4bcd0721, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1456,9 +1627,11 @@ struct ArrayDeleteFragmentsTimestampsRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(aaeeafe1e9f3ea1c, 2, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1471,9 +1644,11 @@ struct ArrayConsolidationRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(f5a35661031194d2, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1486,9 +1661,11 @@ struct ArrayVacuumRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(e68edfc0939e63df, 0, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1501,9 +1678,11 @@ struct LoadEnumerationsRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(891a70a671f15cf6, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1516,9 +1695,11 @@ struct LoadEnumerationsResponse { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(805c080c10c1e959, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1531,9 +1712,11 @@ struct LoadArraySchemaRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(83f094010132ff21, 1, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1546,9 +1729,11 @@ struct LoadArraySchemaResponse { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(ebe17f59ac9a1df1, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1561,9 +1746,11 @@ struct QueryPlanRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(e06f571aa93eb314, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1576,9 +1763,11 @@ struct QueryPlanResponse { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(9fd8fc2f462b2d06, 0, 5) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1591,9 +1780,11 @@ struct ConsolidationPlanRequest { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(8965edf5597ce627, 1, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1606,9 +1797,11 @@ struct ConsolidationPlanResponse { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(aac8bf9b5211388b, 0, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1621,9 +1814,11 @@ struct QueryChannel { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(ca2d4d0bfe4ae5d9, 1, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1636,9 +1831,11 @@ struct Aggregate { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(e193f1f45a9f102e, 0, 3) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1648,16 +1845,18 @@ struct CurrentDomain { class Reader; class Builder; class Pipeline; - enum Which: uint16_t { + enum Which : uint16_t { EMPTY_CURRENT_DOMAIN, ND_RECTANGLE, }; struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(fafb9c94c6b54ec9, 1, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1670,9 +1869,11 @@ struct NDRectangle { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(ce64eabcdabb02b5, 0, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; @@ -1687,20 +1888,24 @@ struct ObjectInfoResponse { struct _capnpPrivate { CAPNP_DECLARE_STRUCT_HEADER(87f0466598bb29be, 1, 0) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE }; }; // ======================================================================================= class DomainArray::Reader { -public: + public: typedef DomainArray Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -1713,36 +1918,46 @@ class DomainArray::Reader { #endif // !CAPNP_LITE inline bool hasInt8() const; - inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Reader getInt8() const; + inline ::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>::Reader getInt8() + const; inline bool hasUint8() const; - inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader getUint8() const; + inline ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader getUint8() + const; inline bool hasInt16() const; - inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Reader getInt16() const; + inline ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>::Reader getInt16() + const; inline bool hasUint16() const; - inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader getUint16() const; + inline ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader getUint16() + const; inline bool hasInt32() const; - inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader getInt32() const; + inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Reader getInt32() + const; inline bool hasUint32() const; - inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader getUint32() const; + inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader getUint32() + const; inline bool hasInt64() const; - inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader getInt64() const; + inline ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>::Reader getInt64() + const; inline bool hasUint64() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getUint64() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getUint64() + const; inline bool hasFloat32() const; - inline ::capnp::List::Reader getFloat32() const; + inline ::capnp::List::Reader getFloat32() + const; inline bool hasFloat64() const; - inline ::capnp::List::Reader getFloat64() const; + inline ::capnp::List::Reader getFloat64() + const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -1755,102 +1970,164 @@ class DomainArray::Reader { }; class DomainArray::Builder { -public: + public: typedef DomainArray Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasInt8(); - inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Builder getInt8(); - inline void setInt8( ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setInt8(::kj::ArrayPtr value); - inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Builder initInt8(unsigned int size); - inline void adoptInt8(::capnp::Orphan< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>> disownInt8(); + inline ::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>::Builder getInt8(); + inline void setInt8( + ::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInt8(::kj::ArrayPtr value); + inline ::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>::Builder initInt8( + unsigned int size); + inline void adoptInt8( + ::capnp::Orphan<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>> + disownInt8(); inline bool hasUint8(); - inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder getUint8(); - inline void setUint8( ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setUint8(::kj::ArrayPtr value); - inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder initUint8(unsigned int size); - inline void adoptUint8(::capnp::Orphan< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>> disownUint8(); + inline ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder getUint8(); + inline void setUint8( + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUint8(::kj::ArrayPtr value); + inline ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder initUint8( + unsigned int size); + inline void adoptUint8( + ::capnp::Orphan<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>> + disownUint8(); inline bool hasInt16(); - inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Builder getInt16(); - inline void setInt16( ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setInt16(::kj::ArrayPtr value); - inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Builder initInt16(unsigned int size); - inline void adoptInt16(::capnp::Orphan< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>> disownInt16(); + inline ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>::Builder getInt16(); + inline void setInt16( + ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInt16(::kj::ArrayPtr value); + inline ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>::Builder initInt16( + unsigned int size); + inline void adoptInt16( + ::capnp::Orphan<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>> + disownInt16(); inline bool hasUint16(); - inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder getUint16(); - inline void setUint16( ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setUint16(::kj::ArrayPtr value); - inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder initUint16(unsigned int size); - inline void adoptUint16(::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>> disownUint16(); + inline ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder + getUint16(); + inline void setUint16( + ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUint16(::kj::ArrayPtr value); + inline ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder + initUint16(unsigned int size); + inline void adoptUint16( + ::capnp::Orphan<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>> + disownUint16(); inline bool hasInt32(); - inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder getInt32(); - inline void setInt32( ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setInt32(::kj::ArrayPtr value); - inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder initInt32(unsigned int size); - inline void adoptInt32(::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>> disownInt32(); + inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Builder getInt32(); + inline void setInt32( + ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInt32(::kj::ArrayPtr value); + inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Builder initInt32( + unsigned int size); + inline void adoptInt32( + ::capnp::Orphan<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>> + disownInt32(); inline bool hasUint32(); - inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder getUint32(); - inline void setUint32( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setUint32(::kj::ArrayPtr value); - inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder initUint32(unsigned int size); - inline void adoptUint32(::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> disownUint32(); + inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder + getUint32(); + inline void setUint32( + ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUint32(::kj::ArrayPtr value); + inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder + initUint32(unsigned int size); + inline void adoptUint32( + ::capnp::Orphan<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>> + disownUint32(); inline bool hasInt64(); - inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder getInt64(); - inline void setInt64( ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setInt64(::kj::ArrayPtr value); - inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder initInt64(unsigned int size); - inline void adoptInt64(::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>> disownInt64(); + inline ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>::Builder getInt64(); + inline void setInt64( + ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setInt64(::kj::ArrayPtr value); + inline ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>::Builder initInt64( + unsigned int size); + inline void adoptInt64( + ::capnp::Orphan<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>> + disownInt64(); inline bool hasUint64(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getUint64(); - inline void setUint64( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setUint64(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initUint64(unsigned int size); - inline void adoptUint64(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownUint64(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getUint64(); + inline void setUint64( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setUint64(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initUint64(unsigned int size); + inline void adoptUint64( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownUint64(); inline bool hasFloat32(); - inline ::capnp::List::Builder getFloat32(); - inline void setFloat32( ::capnp::List::Reader value); + inline ::capnp::List::Builder getFloat32(); + inline void setFloat32( + ::capnp::List::Reader value); inline void setFloat32(::kj::ArrayPtr value); - inline ::capnp::List::Builder initFloat32(unsigned int size); - inline void adoptFloat32(::capnp::Orphan< ::capnp::List>&& value); - inline ::capnp::Orphan< ::capnp::List> disownFloat32(); + inline ::capnp::List::Builder initFloat32( + unsigned int size); + inline void adoptFloat32( + ::capnp::Orphan<::capnp::List>&& value); + inline ::capnp::Orphan<::capnp::List> + disownFloat32(); inline bool hasFloat64(); - inline ::capnp::List::Builder getFloat64(); - inline void setFloat64( ::capnp::List::Reader value); + inline ::capnp::List::Builder getFloat64(); + inline void setFloat64( + ::capnp::List::Reader value); inline void setFloat64(::kj::ArrayPtr value); - inline ::capnp::List::Builder initFloat64(unsigned int size); - inline void adoptFloat64(::capnp::Orphan< ::capnp::List>&& value); - inline ::capnp::Orphan< ::capnp::List> disownFloat64(); - -private: + inline ::capnp::List::Builder initFloat64( + unsigned int size); + inline void adoptFloat64( + ::capnp::Orphan<::capnp::List>&& value); + inline ::capnp::Orphan<::capnp::List> + disownFloat64(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -1861,14 +2138,17 @@ class DomainArray::Builder { #if !CAPNP_LITE class DomainArray::Pipeline { -public: + public: typedef DomainArray Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -1877,11 +2157,13 @@ class DomainArray::Pipeline { #endif // !CAPNP_LITE class KV::Reader { -public: + public: typedef KV Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -1894,12 +2176,12 @@ class KV::Reader { #endif // !CAPNP_LITE inline bool hasKey() const; - inline ::capnp::Text::Reader getKey() const; + inline ::capnp::Text::Reader getKey() const; inline bool hasValue() const; - inline ::capnp::Text::Reader getValue() const; + inline ::capnp::Text::Reader getValue() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -1912,36 +2194,47 @@ class KV::Reader { }; class KV::Builder { -public: + public: typedef KV Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasKey(); - inline ::capnp::Text::Builder getKey(); - inline void setKey( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initKey(unsigned int size); - inline void adoptKey(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownKey(); + inline ::capnp::Text::Builder getKey(); + inline void setKey(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initKey(unsigned int size); + inline void adoptKey(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownKey(); inline bool hasValue(); - inline ::capnp::Text::Builder getValue(); - inline void setValue( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initValue(unsigned int size); - inline void adoptValue(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownValue(); + inline ::capnp::Text::Builder getValue(); + inline void setValue(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initValue(unsigned int size); + inline void adoptValue(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownValue(); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -1952,14 +2245,17 @@ class KV::Builder { #if !CAPNP_LITE class KV::Pipeline { -public: + public: typedef KV Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -1968,11 +2264,13 @@ class KV::Pipeline { #endif // !CAPNP_LITE class Config::Reader { -public: + public: typedef Config Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -1985,9 +2283,12 @@ class Config::Reader { #endif // !CAPNP_LITE inline bool hasEntries() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader getEntries() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>::Reader + getEntries() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -2000,29 +2301,53 @@ class Config::Reader { }; class Config::Builder { -public: + public: typedef Config Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasEntries(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder getEntries(); - inline void setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder initEntries(unsigned int size); - inline void adoptEntries(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>> disownEntries(); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>::Builder + getEntries(); + inline void setEntries(::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>::Builder + initEntries(unsigned int size); + inline void adoptEntries(::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>> + disownEntries(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -2033,14 +2358,17 @@ class Config::Builder { #if !CAPNP_LITE class Config::Pipeline { -public: + public: typedef Config Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -2049,11 +2377,13 @@ class Config::Pipeline { #endif // !CAPNP_LITE class Array::Reader { -public: + public: typedef Array Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -2065,37 +2395,47 @@ class Array::Reader { } #endif // !CAPNP_LITE - inline ::uint64_t getEndTimestamp() const; + inline ::uint64_t getEndTimestamp() const; inline bool hasQueryType() const; - inline ::capnp::Text::Reader getQueryType() const; + inline ::capnp::Text::Reader getQueryType() const; inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; - inline ::uint64_t getStartTimestamp() const; + inline ::uint64_t getStartTimestamp() const; inline bool hasArraySchemaLatest() const; - inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader getArraySchemaLatest() const; + inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader + getArraySchemaLatest() const; inline bool hasArraySchemasAll() const; - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader getArraySchemasAll() const; + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Reader + getArraySchemasAll() const; inline bool hasNonEmptyDomain() const; - inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader getNonEmptyDomain() const; + inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader + getNonEmptyDomain() const; inline bool hasArrayMetadata() const; - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader getArrayMetadata() const; + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader + getArrayMetadata() const; inline bool hasArrayDirectory() const; - inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Reader getArrayDirectory() const; + inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Reader + getArrayDirectory() const; inline bool hasFragmentMetadataAll() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>::Reader getFragmentMetadataAll() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>::Reader + getFragmentMetadataAll() const; - inline ::uint64_t getOpenedAtEndTimestamp() const; + inline ::uint64_t getOpenedAtEndTimestamp() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -2108,87 +2448,151 @@ class Array::Reader { }; class Array::Builder { -public: + public: typedef Array Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE - inline ::uint64_t getEndTimestamp(); - inline void setEndTimestamp( ::uint64_t value); + inline ::uint64_t getEndTimestamp(); + inline void setEndTimestamp(::uint64_t value); inline bool hasQueryType(); - inline ::capnp::Text::Builder getQueryType(); - inline void setQueryType( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initQueryType(unsigned int size); - inline void adoptQueryType(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownQueryType(); + inline ::capnp::Text::Builder getQueryType(); + inline void setQueryType(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initQueryType(unsigned int size); + inline void adoptQueryType(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownQueryType(); inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownUri(); - inline ::uint64_t getStartTimestamp(); - inline void setStartTimestamp( ::uint64_t value); + inline ::uint64_t getStartTimestamp(); + inline void setStartTimestamp(::uint64_t value); inline bool hasArraySchemaLatest(); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder getArraySchemaLatest(); - inline void setArraySchemaLatest( ::tiledb::sm::serialization::capnp::ArraySchema::Reader value); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder initArraySchemaLatest(); - inline void adoptArraySchemaLatest(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema> disownArraySchemaLatest(); + inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder + getArraySchemaLatest(); + inline void setArraySchemaLatest( + ::tiledb::sm::serialization::capnp::ArraySchema::Reader value); + inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder + initArraySchemaLatest(); + inline void adoptArraySchemaLatest( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema> + disownArraySchemaLatest(); inline bool hasArraySchemasAll(); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder getArraySchemasAll(); - inline void setArraySchemasAll( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder initArraySchemasAll(); - inline void adoptArraySchemasAll(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>> disownArraySchemasAll(); + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Builder + getArraySchemasAll(); + inline void setArraySchemasAll( + ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value); + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Builder + initArraySchemasAll(); + inline void adoptArraySchemasAll( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>> + disownArraySchemasAll(); inline bool hasNonEmptyDomain(); - inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder getNonEmptyDomain(); - inline void setNonEmptyDomain( ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader value); - inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder initNonEmptyDomain(); - inline void adoptNonEmptyDomain(::capnp::Orphan< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NonEmptyDomainList> disownNonEmptyDomain(); + inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder + getNonEmptyDomain(); + inline void setNonEmptyDomain( + ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader value); + inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder + initNonEmptyDomain(); + inline void adoptNonEmptyDomain( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::NonEmptyDomainList>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::NonEmptyDomainList> + disownNonEmptyDomain(); inline bool hasArrayMetadata(); - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder getArrayMetadata(); - inline void setArrayMetadata( ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value); - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder initArrayMetadata(); - inline void adoptArrayMetadata(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata> disownArrayMetadata(); + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder + getArrayMetadata(); + inline void setArrayMetadata( + ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value); + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder + initArrayMetadata(); + inline void adoptArrayMetadata( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata> + disownArrayMetadata(); inline bool hasArrayDirectory(); - inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Builder getArrayDirectory(); - inline void setArrayDirectory( ::tiledb::sm::serialization::capnp::ArrayDirectory::Reader value); - inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Builder initArrayDirectory(); - inline void adoptArrayDirectory(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayDirectory>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayDirectory> disownArrayDirectory(); + inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Builder + getArrayDirectory(); + inline void setArrayDirectory( + ::tiledb::sm::serialization::capnp::ArrayDirectory::Reader value); + inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Builder + initArrayDirectory(); + inline void adoptArrayDirectory( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayDirectory>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayDirectory> + disownArrayDirectory(); inline bool hasFragmentMetadataAll(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>::Builder getFragmentMetadataAll(); - inline void setFragmentMetadataAll( ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>::Builder initFragmentMetadataAll(unsigned int size); - inline void adoptFragmentMetadataAll(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>> disownFragmentMetadataAll(); - - inline ::uint64_t getOpenedAtEndTimestamp(); - inline void setOpenedAtEndTimestamp( ::uint64_t value); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>::Builder + getFragmentMetadataAll(); + inline void setFragmentMetadataAll( + ::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>::Builder + initFragmentMetadataAll(unsigned int size); + inline void adoptFragmentMetadataAll( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>> + disownFragmentMetadataAll(); + + inline ::uint64_t getOpenedAtEndTimestamp(); + inline void setOpenedAtEndTimestamp(::uint64_t value); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -2199,19 +2603,30 @@ class Array::Builder { #if !CAPNP_LITE class Array::Pipeline { -public: + public: typedef Array Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - - inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline getArraySchemaLatest(); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline getArraySchemasAll(); - inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline getNonEmptyDomain(); - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline getArrayMetadata(); - inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Pipeline getArrayDirectory(); -private: + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline + getArraySchemaLatest(); + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline + getArraySchemasAll(); + inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline + getNonEmptyDomain(); + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline + getArrayMetadata(); + inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Pipeline + getArrayDirectory(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -2220,11 +2635,13 @@ class Array::Pipeline { #endif // !CAPNP_LITE class ArrayOpen::Reader { -public: + public: typedef ArrayOpen Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -2237,12 +2654,12 @@ class ArrayOpen::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasQueryType() const; - inline ::capnp::Text::Reader getQueryType() const; + inline ::capnp::Text::Reader getQueryType() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -2255,36 +2672,50 @@ class ArrayOpen::Reader { }; class ArrayOpen::Builder { -public: + public: typedef ArrayOpen Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> + disownConfig(); inline bool hasQueryType(); - inline ::capnp::Text::Builder getQueryType(); - inline void setQueryType( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initQueryType(unsigned int size); - inline void adoptQueryType(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownQueryType(); + inline ::capnp::Text::Builder getQueryType(); + inline void setQueryType(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initQueryType(unsigned int size); + inline void adoptQueryType(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownQueryType(); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -2295,15 +2726,19 @@ class ArrayOpen::Builder { #if !CAPNP_LITE class ArrayOpen::Pipeline { -public: + public: typedef ArrayOpen Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -2312,11 +2747,13 @@ class ArrayOpen::Pipeline { #endif // !CAPNP_LITE class ArraySchema::Reader { -public: + public: typedef ArraySchema Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -2329,58 +2766,76 @@ class ArraySchema::Reader { #endif // !CAPNP_LITE inline bool hasArrayType() const; - inline ::capnp::Text::Reader getArrayType() const; + inline ::capnp::Text::Reader getArrayType() const; inline bool hasAttributes() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Reader getAttributes() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>::Reader + getAttributes() const; - inline ::uint64_t getCapacity() const; + inline ::uint64_t getCapacity() const; inline bool hasCellOrder() const; - inline ::capnp::Text::Reader getCellOrder() const; + inline ::capnp::Text::Reader getCellOrder() const; inline bool hasCoordsFilterPipeline() const; - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader getCoordsFilterPipeline() const; + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader + getCoordsFilterPipeline() const; inline bool hasDomain() const; - inline ::tiledb::sm::serialization::capnp::Domain::Reader getDomain() const; + inline ::tiledb::sm::serialization::capnp::Domain::Reader getDomain() const; inline bool hasOffsetFilterPipeline() const; - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader getOffsetFilterPipeline() const; + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader + getOffsetFilterPipeline() const; inline bool hasTileOrder() const; - inline ::capnp::Text::Reader getTileOrder() const; + inline ::capnp::Text::Reader getTileOrder() const; inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; inline bool hasVersion() const; - inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader getVersion() const; + inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Reader getVersion() + const; inline bool getAllowsDuplicates() const; inline bool hasValidityFilterPipeline() const; - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader getValidityFilterPipeline() const; + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader + getValidityFilterPipeline() const; inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; inline bool hasTimestampRange() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTimestampRange() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getTimestampRange() const; inline bool hasDimensionLabels() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>::Reader getDimensionLabels() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>::Reader + getDimensionLabels() const; inline bool hasEnumerations() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader getEnumerations() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader + getEnumerations() const; inline bool hasEnumerationPathMap() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader getEnumerationPathMap() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>::Reader + getEnumerationPathMap() const; inline bool hasCurrentDomain() const; - inline ::tiledb::sm::serialization::capnp::CurrentDomain::Reader getCurrentDomain() const; + inline ::tiledb::sm::serialization::capnp::CurrentDomain::Reader + getCurrentDomain() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -2393,142 +2848,248 @@ class ArraySchema::Reader { }; class ArraySchema::Builder { -public: + public: typedef ArraySchema Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasArrayType(); - inline ::capnp::Text::Builder getArrayType(); - inline void setArrayType( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initArrayType(unsigned int size); - inline void adoptArrayType(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownArrayType(); + inline ::capnp::Text::Builder getArrayType(); + inline void setArrayType(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initArrayType(unsigned int size); + inline void adoptArrayType(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownArrayType(); inline bool hasAttributes(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Builder getAttributes(); - inline void setAttributes( ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Builder initAttributes(unsigned int size); - inline void adoptAttributes(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>> disownAttributes(); - - inline ::uint64_t getCapacity(); - inline void setCapacity( ::uint64_t value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>::Builder + getAttributes(); + inline void setAttributes(::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>::Builder + initAttributes(unsigned int size); + inline void adoptAttributes(::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>> + disownAttributes(); + + inline ::uint64_t getCapacity(); + inline void setCapacity(::uint64_t value); inline bool hasCellOrder(); - inline ::capnp::Text::Builder getCellOrder(); - inline void setCellOrder( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initCellOrder(unsigned int size); - inline void adoptCellOrder(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownCellOrder(); + inline ::capnp::Text::Builder getCellOrder(); + inline void setCellOrder(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initCellOrder(unsigned int size); + inline void adoptCellOrder(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownCellOrder(); inline bool hasCoordsFilterPipeline(); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder getCoordsFilterPipeline(); - inline void setCoordsFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder initCoordsFilterPipeline(); - inline void adoptCoordsFilterPipeline(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> disownCoordsFilterPipeline(); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder + getCoordsFilterPipeline(); + inline void setCoordsFilterPipeline( + ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder + initCoordsFilterPipeline(); + inline void adoptCoordsFilterPipeline( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> + disownCoordsFilterPipeline(); inline bool hasDomain(); - inline ::tiledb::sm::serialization::capnp::Domain::Builder getDomain(); - inline void setDomain( ::tiledb::sm::serialization::capnp::Domain::Reader value); - inline ::tiledb::sm::serialization::capnp::Domain::Builder initDomain(); - inline void adoptDomain(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Domain>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Domain> disownDomain(); + inline ::tiledb::sm::serialization::capnp::Domain::Builder getDomain(); + inline void setDomain( + ::tiledb::sm::serialization::capnp::Domain::Reader value); + inline ::tiledb::sm::serialization::capnp::Domain::Builder initDomain(); + inline void adoptDomain( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Domain>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Domain> + disownDomain(); inline bool hasOffsetFilterPipeline(); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder getOffsetFilterPipeline(); - inline void setOffsetFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder initOffsetFilterPipeline(); - inline void adoptOffsetFilterPipeline(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> disownOffsetFilterPipeline(); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder + getOffsetFilterPipeline(); + inline void setOffsetFilterPipeline( + ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder + initOffsetFilterPipeline(); + inline void adoptOffsetFilterPipeline( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> + disownOffsetFilterPipeline(); inline bool hasTileOrder(); - inline ::capnp::Text::Builder getTileOrder(); - inline void setTileOrder( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initTileOrder(unsigned int size); - inline void adoptTileOrder(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownTileOrder(); + inline ::capnp::Text::Builder getTileOrder(); + inline void setTileOrder(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initTileOrder(unsigned int size); + inline void adoptTileOrder(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownTileOrder(); inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownUri(); inline bool hasVersion(); - inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder getVersion(); - inline void setVersion( ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setVersion(::kj::ArrayPtr value); - inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder initVersion(unsigned int size); - inline void adoptVersion(::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>> disownVersion(); + inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Builder + getVersion(); + inline void setVersion( + ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setVersion(::kj::ArrayPtr value); + inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Builder + initVersion(unsigned int size); + inline void adoptVersion( + ::capnp::Orphan<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>> + disownVersion(); inline bool getAllowsDuplicates(); inline void setAllowsDuplicates(bool value); inline bool hasValidityFilterPipeline(); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder getValidityFilterPipeline(); - inline void setValidityFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder initValidityFilterPipeline(); - inline void adoptValidityFilterPipeline(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> disownValidityFilterPipeline(); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder + getValidityFilterPipeline(); + inline void setValidityFilterPipeline( + ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder + initValidityFilterPipeline(); + inline void adoptValidityFilterPipeline( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> + disownValidityFilterPipeline(); inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownName(); inline bool hasTimestampRange(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTimestampRange(); - inline void setTimestampRange( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTimestampRange(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTimestampRange(unsigned int size); - inline void adoptTimestampRange(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTimestampRange(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getTimestampRange(); + inline void setTimestampRange( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTimestampRange(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initTimestampRange(unsigned int size); + inline void adoptTimestampRange( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownTimestampRange(); inline bool hasDimensionLabels(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>::Builder getDimensionLabels(); - inline void setDimensionLabels( ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>::Builder initDimensionLabels(unsigned int size); - inline void adoptDimensionLabels(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>> disownDimensionLabels(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>::Builder + getDimensionLabels(); + inline void setDimensionLabels( + ::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>::Builder + initDimensionLabels(unsigned int size); + inline void adoptDimensionLabels( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>> + disownDimensionLabels(); inline bool hasEnumerations(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder getEnumerations(); - inline void setEnumerations( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder initEnumerations(unsigned int size); - inline void adoptEnumerations(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> disownEnumerations(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder + getEnumerations(); + inline void setEnumerations(::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder + initEnumerations(unsigned int size); + inline void adoptEnumerations( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>> + disownEnumerations(); inline bool hasEnumerationPathMap(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder getEnumerationPathMap(); - inline void setEnumerationPathMap( ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder initEnumerationPathMap(unsigned int size); - inline void adoptEnumerationPathMap(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>> disownEnumerationPathMap(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>::Builder + getEnumerationPathMap(); + inline void setEnumerationPathMap(::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>::Builder + initEnumerationPathMap(unsigned int size); + inline void adoptEnumerationPathMap( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>> + disownEnumerationPathMap(); inline bool hasCurrentDomain(); - inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder getCurrentDomain(); - inline void setCurrentDomain( ::tiledb::sm::serialization::capnp::CurrentDomain::Reader value); - inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder initCurrentDomain(); - inline void adoptCurrentDomain(::capnp::Orphan< ::tiledb::sm::serialization::capnp::CurrentDomain>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::CurrentDomain> disownCurrentDomain(); - -private: + inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder + getCurrentDomain(); + inline void setCurrentDomain( + ::tiledb::sm::serialization::capnp::CurrentDomain::Reader value); + inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder + initCurrentDomain(); + inline void adoptCurrentDomain( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::CurrentDomain>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::CurrentDomain> + disownCurrentDomain(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -2539,19 +3100,27 @@ class ArraySchema::Builder { #if !CAPNP_LITE class ArraySchema::Pipeline { -public: + public: typedef ArraySchema Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline getCoordsFilterPipeline(); - inline ::tiledb::sm::serialization::capnp::Domain::Pipeline getDomain(); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline getOffsetFilterPipeline(); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline getValidityFilterPipeline(); - inline ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline getCurrentDomain(); -private: + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline + getCoordsFilterPipeline(); + inline ::tiledb::sm::serialization::capnp::Domain::Pipeline getDomain(); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline + getOffsetFilterPipeline(); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline + getValidityFilterPipeline(); + inline ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline + getCurrentDomain(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -2560,11 +3129,13 @@ class ArraySchema::Pipeline { #endif // !CAPNP_LITE class DimensionLabel::Reader { -public: + public: typedef DimensionLabel Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -2576,33 +3147,34 @@ class DimensionLabel::Reader { } #endif // !CAPNP_LITE - inline ::uint32_t getDimensionId() const; + inline ::uint32_t getDimensionId() const; inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; inline bool hasAttributeName() const; - inline ::capnp::Text::Reader getAttributeName() const; + inline ::capnp::Text::Reader getAttributeName() const; inline bool hasOrder() const; - inline ::capnp::Text::Reader getOrder() const; + inline ::capnp::Text::Reader getOrder() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; - inline ::uint32_t getCellValNum() const; + inline ::uint32_t getCellValNum() const; inline bool getExternal() const; inline bool getRelative() const; inline bool hasSchema() const; - inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader getSchema() const; + inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader getSchema() + const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -2615,61 +3187,72 @@ class DimensionLabel::Reader { }; class DimensionLabel::Builder { -public: + public: typedef DimensionLabel Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE - inline ::uint32_t getDimensionId(); - inline void setDimensionId( ::uint32_t value); + inline ::uint32_t getDimensionId(); + inline void setDimensionId(::uint32_t value); inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownName(); inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownUri(); inline bool hasAttributeName(); - inline ::capnp::Text::Builder getAttributeName(); - inline void setAttributeName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initAttributeName(unsigned int size); - inline void adoptAttributeName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownAttributeName(); + inline ::capnp::Text::Builder getAttributeName(); + inline void setAttributeName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initAttributeName(unsigned int size); + inline void adoptAttributeName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownAttributeName(); inline bool hasOrder(); - inline ::capnp::Text::Builder getOrder(); - inline void setOrder( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initOrder(unsigned int size); - inline void adoptOrder(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownOrder(); + inline ::capnp::Text::Builder getOrder(); + inline void setOrder(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initOrder(unsigned int size); + inline void adoptOrder(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownOrder(); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownType(); - inline ::uint32_t getCellValNum(); - inline void setCellValNum( ::uint32_t value); + inline ::uint32_t getCellValNum(); + inline void setCellValNum(::uint32_t value); inline bool getExternal(); inline void setExternal(bool value); @@ -2678,13 +3261,16 @@ class DimensionLabel::Builder { inline void setRelative(bool value); inline bool hasSchema(); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder getSchema(); - inline void setSchema( ::tiledb::sm::serialization::capnp::ArraySchema::Reader value); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder initSchema(); - inline void adoptSchema(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema> disownSchema(); - -private: + inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder getSchema(); + inline void setSchema( + ::tiledb::sm::serialization::capnp::ArraySchema::Reader value); + inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder initSchema(); + inline void adoptSchema( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema> + disownSchema(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -2695,15 +3281,19 @@ class DimensionLabel::Builder { #if !CAPNP_LITE class DimensionLabel::Pipeline { -public: + public: typedef DimensionLabel Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline getSchema(); -private: + inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline getSchema(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -2712,11 +3302,13 @@ class DimensionLabel::Pipeline { #endif // !CAPNP_LITE class ArraySchemaEvolution::Reader { -public: + public: typedef ArraySchemaEvolution Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -2729,27 +3321,40 @@ class ArraySchemaEvolution::Reader { #endif // !CAPNP_LITE inline bool hasAttributesToDrop() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getAttributesToDrop() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getAttributesToDrop() const; inline bool hasAttributesToAdd() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Reader getAttributesToAdd() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>::Reader + getAttributesToAdd() const; inline bool hasTimestampRange() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTimestampRange() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getTimestampRange() const; inline bool hasEnumerationsToAdd() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader getEnumerationsToAdd() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader + getEnumerationsToAdd() const; inline bool hasEnumerationsToDrop() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getEnumerationsToDrop() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getEnumerationsToDrop() const; inline bool hasEnumerationsToExtend() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader getEnumerationsToExtend() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader + getEnumerationsToExtend() const; inline bool hasCurrentDomainToExpand() const; - inline ::tiledb::sm::serialization::capnp::CurrentDomain::Reader getCurrentDomainToExpand() const; + inline ::tiledb::sm::serialization::capnp::CurrentDomain::Reader + getCurrentDomainToExpand() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -2762,74 +3367,155 @@ class ArraySchemaEvolution::Reader { }; class ArraySchemaEvolution::Builder { -public: + public: typedef ArraySchemaEvolution Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasAttributesToDrop(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getAttributesToDrop(); - inline void setAttributesToDrop( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setAttributesToDrop(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initAttributesToDrop(unsigned int size); - inline void adoptAttributesToDrop(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownAttributesToDrop(); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getAttributesToDrop(); + inline void setAttributesToDrop( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setAttributesToDrop( + ::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initAttributesToDrop(unsigned int size); + inline void adoptAttributesToDrop( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownAttributesToDrop(); inline bool hasAttributesToAdd(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Builder getAttributesToAdd(); - inline void setAttributesToAdd( ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Builder initAttributesToAdd(unsigned int size); - inline void adoptAttributesToAdd(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>> disownAttributesToAdd(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>::Builder + getAttributesToAdd(); + inline void setAttributesToAdd(::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>::Builder + initAttributesToAdd(unsigned int size); + inline void adoptAttributesToAdd( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>> + disownAttributesToAdd(); inline bool hasTimestampRange(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTimestampRange(); - inline void setTimestampRange( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTimestampRange(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTimestampRange(unsigned int size); - inline void adoptTimestampRange(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTimestampRange(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getTimestampRange(); + inline void setTimestampRange( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTimestampRange(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initTimestampRange(unsigned int size); + inline void adoptTimestampRange( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownTimestampRange(); inline bool hasEnumerationsToAdd(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder getEnumerationsToAdd(); - inline void setEnumerationsToAdd( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder initEnumerationsToAdd(unsigned int size); - inline void adoptEnumerationsToAdd(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> disownEnumerationsToAdd(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder + getEnumerationsToAdd(); + inline void setEnumerationsToAdd( + ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder + initEnumerationsToAdd(unsigned int size); + inline void adoptEnumerationsToAdd( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>> + disownEnumerationsToAdd(); inline bool hasEnumerationsToDrop(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getEnumerationsToDrop(); - inline void setEnumerationsToDrop( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setEnumerationsToDrop(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initEnumerationsToDrop(unsigned int size); - inline void adoptEnumerationsToDrop(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownEnumerationsToDrop(); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getEnumerationsToDrop(); + inline void setEnumerationsToDrop( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setEnumerationsToDrop( + ::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initEnumerationsToDrop(unsigned int size); + inline void adoptEnumerationsToDrop( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownEnumerationsToDrop(); inline bool hasEnumerationsToExtend(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder getEnumerationsToExtend(); - inline void setEnumerationsToExtend( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder initEnumerationsToExtend(unsigned int size); - inline void adoptEnumerationsToExtend(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> disownEnumerationsToExtend(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder + getEnumerationsToExtend(); + inline void setEnumerationsToExtend( + ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder + initEnumerationsToExtend(unsigned int size); + inline void adoptEnumerationsToExtend( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>> + disownEnumerationsToExtend(); inline bool hasCurrentDomainToExpand(); - inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder getCurrentDomainToExpand(); - inline void setCurrentDomainToExpand( ::tiledb::sm::serialization::capnp::CurrentDomain::Reader value); - inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder initCurrentDomainToExpand(); - inline void adoptCurrentDomainToExpand(::capnp::Orphan< ::tiledb::sm::serialization::capnp::CurrentDomain>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::CurrentDomain> disownCurrentDomainToExpand(); - -private: + inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder + getCurrentDomainToExpand(); + inline void setCurrentDomainToExpand( + ::tiledb::sm::serialization::capnp::CurrentDomain::Reader value); + inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder + initCurrentDomainToExpand(); + inline void adoptCurrentDomainToExpand( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::CurrentDomain>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::CurrentDomain> + disownCurrentDomainToExpand(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -2840,15 +3526,20 @@ class ArraySchemaEvolution::Builder { #if !CAPNP_LITE class ArraySchemaEvolution::Pipeline { -public: + public: typedef ArraySchemaEvolution Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline + getCurrentDomainToExpand(); - inline ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline getCurrentDomainToExpand(); -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -2857,11 +3548,13 @@ class ArraySchemaEvolution::Pipeline { #endif // !CAPNP_LITE class Attribute::Reader { -public: + public: typedef Attribute Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -2873,31 +3566,32 @@ class Attribute::Reader { } #endif // !CAPNP_LITE - inline ::uint32_t getCellValNum() const; + inline ::uint32_t getCellValNum() const; inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; inline bool hasFilterPipeline() const; - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader getFilterPipeline() const; + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader + getFilterPipeline() const; inline bool hasFillValue() const; - inline ::capnp::Data::Reader getFillValue() const; + inline ::capnp::Data::Reader getFillValue() const; inline bool getNullable() const; inline bool getFillValueValidity() const; inline bool hasOrder() const; - inline ::capnp::Text::Reader getOrder() const; + inline ::capnp::Text::Reader getOrder() const; inline bool hasEnumerationName() const; - inline ::capnp::Text::Reader getEnumerationName() const; + inline ::capnp::Text::Reader getEnumerationName() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -2910,51 +3604,68 @@ class Attribute::Reader { }; class Attribute::Builder { -public: + public: typedef Attribute Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE - inline ::uint32_t getCellValNum(); - inline void setCellValNum( ::uint32_t value); + inline ::uint32_t getCellValNum(); + inline void setCellValNum(::uint32_t value); inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownName(); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownType(); inline bool hasFilterPipeline(); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder getFilterPipeline(); - inline void setFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder initFilterPipeline(); - inline void adoptFilterPipeline(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> disownFilterPipeline(); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder + getFilterPipeline(); + inline void setFilterPipeline( + ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder + initFilterPipeline(); + inline void adoptFilterPipeline( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> + disownFilterPipeline(); inline bool hasFillValue(); - inline ::capnp::Data::Builder getFillValue(); - inline void setFillValue( ::capnp::Data::Reader value); - inline ::capnp::Data::Builder initFillValue(unsigned int size); - inline void adoptFillValue(::capnp::Orphan< ::capnp::Data>&& value); - inline ::capnp::Orphan< ::capnp::Data> disownFillValue(); + inline ::capnp::Data::Builder getFillValue(); + inline void setFillValue(::capnp::Data::Reader value); + inline ::capnp::Data::Builder initFillValue(unsigned int size); + inline void adoptFillValue(::capnp::Orphan<::capnp::Data>&& value); + inline ::capnp::Orphan<::capnp::Data> disownFillValue(); inline bool getNullable(); inline void setNullable(bool value); @@ -2963,20 +3674,20 @@ class Attribute::Builder { inline void setFillValueValidity(bool value); inline bool hasOrder(); - inline ::capnp::Text::Builder getOrder(); - inline void setOrder( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initOrder(unsigned int size); - inline void adoptOrder(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownOrder(); + inline ::capnp::Text::Builder getOrder(); + inline void setOrder(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initOrder(unsigned int size); + inline void adoptOrder(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownOrder(); inline bool hasEnumerationName(); - inline ::capnp::Text::Builder getEnumerationName(); - inline void setEnumerationName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initEnumerationName(unsigned int size); - inline void adoptEnumerationName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownEnumerationName(); + inline ::capnp::Text::Builder getEnumerationName(); + inline void setEnumerationName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initEnumerationName(unsigned int size); + inline void adoptEnumerationName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownEnumerationName(); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -2987,15 +3698,20 @@ class Attribute::Builder { #if !CAPNP_LITE class Attribute::Pipeline { -public: + public: typedef Attribute Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline + getFilterPipeline(); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline getFilterPipeline(); -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -3004,11 +3720,13 @@ class Attribute::Pipeline { #endif // !CAPNP_LITE class Enumeration::Reader { -public: + public: typedef Enumeration Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -3021,25 +3739,25 @@ class Enumeration::Reader { #endif // !CAPNP_LITE inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; inline bool hasPathName() const; - inline ::capnp::Text::Reader getPathName() const; + inline ::capnp::Text::Reader getPathName() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; - inline ::uint32_t getCellValNum() const; + inline ::uint32_t getCellValNum() const; inline bool getOrdered() const; inline bool hasData() const; - inline ::capnp::Data::Reader getData() const; + inline ::capnp::Data::Reader getData() const; inline bool hasOffsets() const; - inline ::capnp::Data::Reader getOffsets() const; + inline ::capnp::Data::Reader getOffsets() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -3052,63 +3770,74 @@ class Enumeration::Reader { }; class Enumeration::Builder { -public: + public: typedef Enumeration Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownName(); inline bool hasPathName(); - inline ::capnp::Text::Builder getPathName(); - inline void setPathName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initPathName(unsigned int size); - inline void adoptPathName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownPathName(); + inline ::capnp::Text::Builder getPathName(); + inline void setPathName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPathName(unsigned int size); + inline void adoptPathName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownPathName(); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownType(); - inline ::uint32_t getCellValNum(); - inline void setCellValNum( ::uint32_t value); + inline ::uint32_t getCellValNum(); + inline void setCellValNum(::uint32_t value); inline bool getOrdered(); inline void setOrdered(bool value); inline bool hasData(); - inline ::capnp::Data::Builder getData(); - inline void setData( ::capnp::Data::Reader value); - inline ::capnp::Data::Builder initData(unsigned int size); - inline void adoptData(::capnp::Orphan< ::capnp::Data>&& value); - inline ::capnp::Orphan< ::capnp::Data> disownData(); + inline ::capnp::Data::Builder getData(); + inline void setData(::capnp::Data::Reader value); + inline ::capnp::Data::Builder initData(unsigned int size); + inline void adoptData(::capnp::Orphan<::capnp::Data>&& value); + inline ::capnp::Orphan<::capnp::Data> disownData(); inline bool hasOffsets(); - inline ::capnp::Data::Builder getOffsets(); - inline void setOffsets( ::capnp::Data::Reader value); - inline ::capnp::Data::Builder initOffsets(unsigned int size); - inline void adoptOffsets(::capnp::Orphan< ::capnp::Data>&& value); - inline ::capnp::Orphan< ::capnp::Data> disownOffsets(); + inline ::capnp::Data::Builder getOffsets(); + inline void setOffsets(::capnp::Data::Reader value); + inline ::capnp::Data::Builder initOffsets(unsigned int size); + inline void adoptOffsets(::capnp::Orphan<::capnp::Data>&& value); + inline ::capnp::Orphan<::capnp::Data> disownOffsets(); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -3119,14 +3848,17 @@ class Enumeration::Builder { #if !CAPNP_LITE class Enumeration::Pipeline { -public: + public: typedef Enumeration Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -3135,11 +3867,13 @@ class Enumeration::Pipeline { #endif // !CAPNP_LITE class AttributeBufferHeader::Reader { -public: + public: typedef AttributeBufferHeader Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -3152,21 +3886,21 @@ class AttributeBufferHeader::Reader { #endif // !CAPNP_LITE inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; - inline ::uint64_t getFixedLenBufferSizeInBytes() const; + inline ::uint64_t getFixedLenBufferSizeInBytes() const; - inline ::uint64_t getVarLenBufferSizeInBytes() const; + inline ::uint64_t getVarLenBufferSizeInBytes() const; - inline ::uint64_t getValidityLenBufferSizeInBytes() const; + inline ::uint64_t getValidityLenBufferSizeInBytes() const; - inline ::uint64_t getOriginalFixedLenBufferSizeInBytes() const; + inline ::uint64_t getOriginalFixedLenBufferSizeInBytes() const; - inline ::uint64_t getOriginalVarLenBufferSizeInBytes() const; + inline ::uint64_t getOriginalVarLenBufferSizeInBytes() const; - inline ::uint64_t getOriginalValidityLenBufferSizeInBytes() const; + inline ::uint64_t getOriginalValidityLenBufferSizeInBytes() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -3179,47 +3913,58 @@ class AttributeBufferHeader::Reader { }; class AttributeBufferHeader::Builder { -public: + public: typedef AttributeBufferHeader Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownName(); - inline ::uint64_t getFixedLenBufferSizeInBytes(); - inline void setFixedLenBufferSizeInBytes( ::uint64_t value); + inline ::uint64_t getFixedLenBufferSizeInBytes(); + inline void setFixedLenBufferSizeInBytes(::uint64_t value); - inline ::uint64_t getVarLenBufferSizeInBytes(); - inline void setVarLenBufferSizeInBytes( ::uint64_t value); + inline ::uint64_t getVarLenBufferSizeInBytes(); + inline void setVarLenBufferSizeInBytes(::uint64_t value); - inline ::uint64_t getValidityLenBufferSizeInBytes(); - inline void setValidityLenBufferSizeInBytes( ::uint64_t value); + inline ::uint64_t getValidityLenBufferSizeInBytes(); + inline void setValidityLenBufferSizeInBytes(::uint64_t value); - inline ::uint64_t getOriginalFixedLenBufferSizeInBytes(); - inline void setOriginalFixedLenBufferSizeInBytes( ::uint64_t value); + inline ::uint64_t getOriginalFixedLenBufferSizeInBytes(); + inline void setOriginalFixedLenBufferSizeInBytes(::uint64_t value); - inline ::uint64_t getOriginalVarLenBufferSizeInBytes(); - inline void setOriginalVarLenBufferSizeInBytes( ::uint64_t value); + inline ::uint64_t getOriginalVarLenBufferSizeInBytes(); + inline void setOriginalVarLenBufferSizeInBytes(::uint64_t value); - inline ::uint64_t getOriginalValidityLenBufferSizeInBytes(); - inline void setOriginalValidityLenBufferSizeInBytes( ::uint64_t value); + inline ::uint64_t getOriginalValidityLenBufferSizeInBytes(); + inline void setOriginalValidityLenBufferSizeInBytes(::uint64_t value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -3230,14 +3975,17 @@ class AttributeBufferHeader::Builder { #if !CAPNP_LITE class AttributeBufferHeader::Pipeline { -public: + public: typedef AttributeBufferHeader Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -3246,11 +3994,13 @@ class AttributeBufferHeader::Pipeline { #endif // !CAPNP_LITE class Dimension::Reader { -public: + public: typedef Dimension Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -3263,22 +4013,24 @@ class Dimension::Reader { #endif // !CAPNP_LITE inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; inline bool getNullTileExtent() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; inline typename TileExtent::Reader getTileExtent() const; inline bool hasDomain() const; - inline ::tiledb::sm::serialization::capnp::DomainArray::Reader getDomain() const; + inline ::tiledb::sm::serialization::capnp::DomainArray::Reader getDomain() + const; inline bool hasFilterPipeline() const; - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader getFilterPipeline() const; + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader + getFilterPipeline() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -3291,56 +4043,76 @@ class Dimension::Reader { }; class Dimension::Builder { -public: + public: typedef Dimension Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownName(); inline bool getNullTileExtent(); inline void setNullTileExtent(bool value); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownType(); inline typename TileExtent::Builder getTileExtent(); inline typename TileExtent::Builder initTileExtent(); inline bool hasDomain(); - inline ::tiledb::sm::serialization::capnp::DomainArray::Builder getDomain(); - inline void setDomain( ::tiledb::sm::serialization::capnp::DomainArray::Reader value); - inline ::tiledb::sm::serialization::capnp::DomainArray::Builder initDomain(); - inline void adoptDomain(::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray> disownDomain(); + inline ::tiledb::sm::serialization::capnp::DomainArray::Builder getDomain(); + inline void setDomain( + ::tiledb::sm::serialization::capnp::DomainArray::Reader value); + inline ::tiledb::sm::serialization::capnp::DomainArray::Builder initDomain(); + inline void adoptDomain( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray> + disownDomain(); inline bool hasFilterPipeline(); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder getFilterPipeline(); - inline void setFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder initFilterPipeline(); - inline void adoptFilterPipeline(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> disownFilterPipeline(); - -private: + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder + getFilterPipeline(); + inline void setFilterPipeline( + ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder + initFilterPipeline(); + inline void adoptFilterPipeline( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> + disownFilterPipeline(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -3351,17 +4123,22 @@ class Dimension::Builder { #if !CAPNP_LITE class Dimension::Pipeline { -public: + public: typedef Dimension Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } inline typename TileExtent::Pipeline getTileExtent(); - inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline getDomain(); - inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline getFilterPipeline(); -private: + inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline getDomain(); + inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline + getFilterPipeline(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -3370,11 +4147,13 @@ class Dimension::Pipeline { #endif // !CAPNP_LITE class Dimension::TileExtent::Reader { -public: + public: typedef TileExtent Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -3388,28 +4167,28 @@ class Dimension::TileExtent::Reader { inline Which which() const; inline bool isInt8() const; - inline ::int8_t getInt8() const; + inline ::int8_t getInt8() const; inline bool isUint8() const; - inline ::uint8_t getUint8() const; + inline ::uint8_t getUint8() const; inline bool isInt16() const; - inline ::int16_t getInt16() const; + inline ::int16_t getInt16() const; inline bool isUint16() const; - inline ::uint16_t getUint16() const; + inline ::uint16_t getUint16() const; inline bool isInt32() const; - inline ::int32_t getInt32() const; + inline ::int32_t getInt32() const; inline bool isUint32() const; - inline ::uint32_t getUint32() const; + inline ::uint32_t getUint32() const; inline bool isInt64() const; - inline ::int64_t getInt64() const; + inline ::int64_t getInt64() const; inline bool isUint64() const; - inline ::uint64_t getUint64() const; + inline ::uint64_t getUint64() const; inline bool isFloat32() const; inline float getFloat32() const; @@ -3417,7 +4196,7 @@ class Dimension::TileExtent::Reader { inline bool isFloat64() const; inline double getFloat64() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -3430,53 +4209,64 @@ class Dimension::TileExtent::Reader { }; class Dimension::TileExtent::Builder { -public: + public: typedef TileExtent Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline Which which(); inline bool isInt8(); - inline ::int8_t getInt8(); - inline void setInt8( ::int8_t value); + inline ::int8_t getInt8(); + inline void setInt8(::int8_t value); inline bool isUint8(); - inline ::uint8_t getUint8(); - inline void setUint8( ::uint8_t value); + inline ::uint8_t getUint8(); + inline void setUint8(::uint8_t value); inline bool isInt16(); - inline ::int16_t getInt16(); - inline void setInt16( ::int16_t value); + inline ::int16_t getInt16(); + inline void setInt16(::int16_t value); inline bool isUint16(); - inline ::uint16_t getUint16(); - inline void setUint16( ::uint16_t value); + inline ::uint16_t getUint16(); + inline void setUint16(::uint16_t value); inline bool isInt32(); - inline ::int32_t getInt32(); - inline void setInt32( ::int32_t value); + inline ::int32_t getInt32(); + inline void setInt32(::int32_t value); inline bool isUint32(); - inline ::uint32_t getUint32(); - inline void setUint32( ::uint32_t value); + inline ::uint32_t getUint32(); + inline void setUint32(::uint32_t value); inline bool isInt64(); - inline ::int64_t getInt64(); - inline void setInt64( ::int64_t value); + inline ::int64_t getInt64(); + inline void setInt64(::int64_t value); inline bool isUint64(); - inline ::uint64_t getUint64(); - inline void setUint64( ::uint64_t value); + inline ::uint64_t getUint64(); + inline void setUint64(::uint64_t value); inline bool isFloat32(); inline float getFloat32(); @@ -3486,7 +4276,7 @@ class Dimension::TileExtent::Builder { inline double getFloat64(); inline void setFloat64(double value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -3497,14 +4287,17 @@ class Dimension::TileExtent::Builder { #if !CAPNP_LITE class Dimension::TileExtent::Pipeline { -public: + public: typedef TileExtent Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -3513,11 +4306,13 @@ class Dimension::TileExtent::Pipeline { #endif // !CAPNP_LITE class Domain::Reader { -public: + public: typedef Domain Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -3530,18 +4325,21 @@ class Domain::Reader { #endif // !CAPNP_LITE inline bool hasCellOrder() const; - inline ::capnp::Text::Reader getCellOrder() const; + inline ::capnp::Text::Reader getCellOrder() const; inline bool hasDimensions() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>::Reader getDimensions() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>::Reader + getDimensions() const; inline bool hasTileOrder() const; - inline ::capnp::Text::Reader getTileOrder() const; + inline ::capnp::Text::Reader getTileOrder() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -3554,50 +4352,74 @@ class Domain::Reader { }; class Domain::Builder { -public: + public: typedef Domain Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasCellOrder(); - inline ::capnp::Text::Builder getCellOrder(); - inline void setCellOrder( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initCellOrder(unsigned int size); - inline void adoptCellOrder(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownCellOrder(); + inline ::capnp::Text::Builder getCellOrder(); + inline void setCellOrder(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initCellOrder(unsigned int size); + inline void adoptCellOrder(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownCellOrder(); inline bool hasDimensions(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>::Builder getDimensions(); - inline void setDimensions( ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>::Builder initDimensions(unsigned int size); - inline void adoptDimensions(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>> disownDimensions(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>::Builder + getDimensions(); + inline void setDimensions(::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>::Builder + initDimensions(unsigned int size); + inline void adoptDimensions(::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>> + disownDimensions(); inline bool hasTileOrder(); - inline ::capnp::Text::Builder getTileOrder(); - inline void setTileOrder( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initTileOrder(unsigned int size); - inline void adoptTileOrder(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownTileOrder(); + inline ::capnp::Text::Builder getTileOrder(); + inline void setTileOrder(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initTileOrder(unsigned int size); + inline void adoptTileOrder(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownTileOrder(); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownType(); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -3608,14 +4430,17 @@ class Domain::Builder { #if !CAPNP_LITE class Domain::Pipeline { -public: + public: typedef Domain Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -3624,11 +4449,13 @@ class Domain::Pipeline { #endif // !CAPNP_LITE class Error::Reader { -public: + public: typedef Error Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -3640,12 +4467,12 @@ class Error::Reader { } #endif // !CAPNP_LITE - inline ::int64_t getCode() const; + inline ::int64_t getCode() const; inline bool hasMessage() const; - inline ::capnp::Text::Reader getMessage() const; + inline ::capnp::Text::Reader getMessage() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -3658,32 +4485,43 @@ class Error::Reader { }; class Error::Builder { -public: + public: typedef Error Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE - inline ::int64_t getCode(); - inline void setCode( ::int64_t value); + inline ::int64_t getCode(); + inline void setCode(::int64_t value); inline bool hasMessage(); - inline ::capnp::Text::Builder getMessage(); - inline void setMessage( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initMessage(unsigned int size); - inline void adoptMessage(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownMessage(); + inline ::capnp::Text::Builder getMessage(); + inline void setMessage(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initMessage(unsigned int size); + inline void adoptMessage(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownMessage(); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -3694,14 +4532,17 @@ class Error::Builder { #if !CAPNP_LITE class Error::Pipeline { -public: + public: typedef Error Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -3710,11 +4551,13 @@ class Error::Pipeline { #endif // !CAPNP_LITE class FloatScaleConfig::Reader { -public: + public: typedef FloatScaleConfig Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -3730,9 +4573,9 @@ class FloatScaleConfig::Reader { inline double getOffset() const; - inline ::uint64_t getByteWidth() const; + inline ::uint64_t getByteWidth() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -3745,19 +4588,30 @@ class FloatScaleConfig::Reader { }; class FloatScaleConfig::Builder { -public: + public: typedef FloatScaleConfig Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline double getScale(); @@ -3766,10 +4620,10 @@ class FloatScaleConfig::Builder { inline double getOffset(); inline void setOffset(double value); - inline ::uint64_t getByteWidth(); - inline void setByteWidth( ::uint64_t value); + inline ::uint64_t getByteWidth(); + inline void setByteWidth(::uint64_t value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -3780,14 +4634,17 @@ class FloatScaleConfig::Builder { #if !CAPNP_LITE class FloatScaleConfig::Pipeline { -public: + public: typedef FloatScaleConfig Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -3796,11 +4653,13 @@ class FloatScaleConfig::Pipeline { #endif // !CAPNP_LITE class WebpConfig::Reader { -public: + public: typedef WebpConfig Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -3814,15 +4673,15 @@ class WebpConfig::Reader { inline float getQuality() const; - inline ::uint8_t getFormat() const; + inline ::uint8_t getFormat() const; inline bool getLossless() const; - inline ::uint16_t getExtentX() const; + inline ::uint16_t getExtentX() const; - inline ::uint16_t getExtentY() const; + inline ::uint16_t getExtentY() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -3835,37 +4694,48 @@ class WebpConfig::Reader { }; class WebpConfig::Builder { -public: + public: typedef WebpConfig Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline float getQuality(); inline void setQuality(float value); - inline ::uint8_t getFormat(); - inline void setFormat( ::uint8_t value); + inline ::uint8_t getFormat(); + inline void setFormat(::uint8_t value); inline bool getLossless(); inline void setLossless(bool value); - inline ::uint16_t getExtentX(); - inline void setExtentX( ::uint16_t value); + inline ::uint16_t getExtentX(); + inline void setExtentX(::uint16_t value); - inline ::uint16_t getExtentY(); - inline void setExtentY( ::uint16_t value); + inline ::uint16_t getExtentY(); + inline void setExtentY(::uint16_t value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -3876,14 +4746,17 @@ class WebpConfig::Builder { #if !CAPNP_LITE class WebpConfig::Pipeline { -public: + public: typedef WebpConfig Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -3892,11 +4765,13 @@ class WebpConfig::Pipeline { #endif // !CAPNP_LITE class Filter::Reader { -public: + public: typedef Filter Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -3909,17 +4784,19 @@ class Filter::Reader { #endif // !CAPNP_LITE inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; inline typename Data::Reader getData() const; inline bool hasFloatScaleConfig() const; - inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Reader getFloatScaleConfig() const; + inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Reader + getFloatScaleConfig() const; inline bool hasWebpConfig() const; - inline ::tiledb::sm::serialization::capnp::WebpConfig::Reader getWebpConfig() const; + inline ::tiledb::sm::serialization::capnp::WebpConfig::Reader getWebpConfig() + const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -3932,46 +4809,68 @@ class Filter::Reader { }; class Filter::Builder { -public: + public: typedef Filter Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownType(); inline typename Data::Builder getData(); inline typename Data::Builder initData(); inline bool hasFloatScaleConfig(); - inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Builder getFloatScaleConfig(); - inline void setFloatScaleConfig( ::tiledb::sm::serialization::capnp::FloatScaleConfig::Reader value); - inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Builder initFloatScaleConfig(); - inline void adoptFloatScaleConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FloatScaleConfig>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FloatScaleConfig> disownFloatScaleConfig(); + inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Builder + getFloatScaleConfig(); + inline void setFloatScaleConfig( + ::tiledb::sm::serialization::capnp::FloatScaleConfig::Reader value); + inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Builder + initFloatScaleConfig(); + inline void adoptFloatScaleConfig( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FloatScaleConfig>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FloatScaleConfig> + disownFloatScaleConfig(); inline bool hasWebpConfig(); - inline ::tiledb::sm::serialization::capnp::WebpConfig::Builder getWebpConfig(); - inline void setWebpConfig( ::tiledb::sm::serialization::capnp::WebpConfig::Reader value); - inline ::tiledb::sm::serialization::capnp::WebpConfig::Builder initWebpConfig(); - inline void adoptWebpConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::WebpConfig>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::WebpConfig> disownWebpConfig(); - -private: + inline ::tiledb::sm::serialization::capnp::WebpConfig::Builder + getWebpConfig(); + inline void setWebpConfig( + ::tiledb::sm::serialization::capnp::WebpConfig::Reader value); + inline ::tiledb::sm::serialization::capnp::WebpConfig::Builder + initWebpConfig(); + inline void adoptWebpConfig( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::WebpConfig>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::WebpConfig> + disownWebpConfig(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -3982,17 +4881,23 @@ class Filter::Builder { #if !CAPNP_LITE class Filter::Pipeline { -public: + public: typedef Filter Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } inline typename Data::Pipeline getData(); - inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Pipeline getFloatScaleConfig(); - inline ::tiledb::sm::serialization::capnp::WebpConfig::Pipeline getWebpConfig(); -private: + inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Pipeline + getFloatScaleConfig(); + inline ::tiledb::sm::serialization::capnp::WebpConfig::Pipeline + getWebpConfig(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4001,11 +4906,13 @@ class Filter::Pipeline { #endif // !CAPNP_LITE class Filter::Data::Reader { -public: + public: typedef Data Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4020,35 +4927,35 @@ class Filter::Data::Reader { inline Which which() const; inline bool isText() const; inline bool hasText() const; - inline ::capnp::Text::Reader getText() const; + inline ::capnp::Text::Reader getText() const; inline bool isBytes() const; inline bool hasBytes() const; - inline ::capnp::Data::Reader getBytes() const; + inline ::capnp::Data::Reader getBytes() const; inline bool isInt8() const; - inline ::int8_t getInt8() const; + inline ::int8_t getInt8() const; inline bool isUint8() const; - inline ::uint8_t getUint8() const; + inline ::uint8_t getUint8() const; inline bool isInt16() const; - inline ::int16_t getInt16() const; + inline ::int16_t getInt16() const; inline bool isUint16() const; - inline ::uint16_t getUint16() const; + inline ::uint16_t getUint16() const; inline bool isInt32() const; - inline ::int32_t getInt32() const; + inline ::int32_t getInt32() const; inline bool isUint32() const; - inline ::uint32_t getUint32() const; + inline ::uint32_t getUint32() const; inline bool isInt64() const; - inline ::int64_t getInt64() const; + inline ::int64_t getInt64() const; inline bool isUint64() const; - inline ::uint64_t getUint64() const; + inline ::uint64_t getUint64() const; inline bool isFloat32() const; inline float getFloat32() const; @@ -4056,7 +4963,7 @@ class Filter::Data::Reader { inline bool isFloat64() const; inline double getFloat64() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4069,69 +4976,80 @@ class Filter::Data::Reader { }; class Filter::Data::Builder { -public: + public: typedef Data Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline Which which(); inline bool isText(); inline bool hasText(); - inline ::capnp::Text::Builder getText(); - inline void setText( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initText(unsigned int size); - inline void adoptText(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownText(); + inline ::capnp::Text::Builder getText(); + inline void setText(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initText(unsigned int size); + inline void adoptText(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownText(); inline bool isBytes(); inline bool hasBytes(); - inline ::capnp::Data::Builder getBytes(); - inline void setBytes( ::capnp::Data::Reader value); - inline ::capnp::Data::Builder initBytes(unsigned int size); - inline void adoptBytes(::capnp::Orphan< ::capnp::Data>&& value); - inline ::capnp::Orphan< ::capnp::Data> disownBytes(); + inline ::capnp::Data::Builder getBytes(); + inline void setBytes(::capnp::Data::Reader value); + inline ::capnp::Data::Builder initBytes(unsigned int size); + inline void adoptBytes(::capnp::Orphan<::capnp::Data>&& value); + inline ::capnp::Orphan<::capnp::Data> disownBytes(); inline bool isInt8(); - inline ::int8_t getInt8(); - inline void setInt8( ::int8_t value); + inline ::int8_t getInt8(); + inline void setInt8(::int8_t value); inline bool isUint8(); - inline ::uint8_t getUint8(); - inline void setUint8( ::uint8_t value); + inline ::uint8_t getUint8(); + inline void setUint8(::uint8_t value); inline bool isInt16(); - inline ::int16_t getInt16(); - inline void setInt16( ::int16_t value); + inline ::int16_t getInt16(); + inline void setInt16(::int16_t value); inline bool isUint16(); - inline ::uint16_t getUint16(); - inline void setUint16( ::uint16_t value); + inline ::uint16_t getUint16(); + inline void setUint16(::uint16_t value); inline bool isInt32(); - inline ::int32_t getInt32(); - inline void setInt32( ::int32_t value); + inline ::int32_t getInt32(); + inline void setInt32(::int32_t value); inline bool isUint32(); - inline ::uint32_t getUint32(); - inline void setUint32( ::uint32_t value); + inline ::uint32_t getUint32(); + inline void setUint32(::uint32_t value); inline bool isInt64(); - inline ::int64_t getInt64(); - inline void setInt64( ::int64_t value); + inline ::int64_t getInt64(); + inline void setInt64(::int64_t value); inline bool isUint64(); - inline ::uint64_t getUint64(); - inline void setUint64( ::uint64_t value); + inline ::uint64_t getUint64(); + inline void setUint64(::uint64_t value); inline bool isFloat32(); inline float getFloat32(); @@ -4141,7 +5059,7 @@ class Filter::Data::Builder { inline double getFloat64(); inline void setFloat64(double value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -4152,14 +5070,17 @@ class Filter::Data::Builder { #if !CAPNP_LITE class Filter::Data::Pipeline { -public: + public: typedef Data Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4168,11 +5089,13 @@ class Filter::Data::Pipeline { #endif // !CAPNP_LITE class FilterPipeline::Reader { -public: + public: typedef FilterPipeline Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4185,9 +5108,12 @@ class FilterPipeline::Reader { #endif // !CAPNP_LITE inline bool hasFilters() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>::Reader getFilters() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>::Reader + getFilters() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4200,29 +5126,53 @@ class FilterPipeline::Reader { }; class FilterPipeline::Builder { -public: + public: typedef FilterPipeline Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasFilters(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>::Builder getFilters(); - inline void setFilters( ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>::Builder initFilters(unsigned int size); - inline void adoptFilters(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>> disownFilters(); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>::Builder + getFilters(); + inline void setFilters(::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>::Builder + initFilters(unsigned int size); + inline void adoptFilters(::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>> + disownFilters(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -4233,14 +5183,17 @@ class FilterPipeline::Builder { #if !CAPNP_LITE class FilterPipeline::Pipeline { -public: + public: typedef FilterPipeline Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4250,11 +5203,13 @@ class FilterPipeline::Pipeline { template class Map::Reader { -public: + public: typedef Map Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4266,15 +5221,20 @@ class Map::Reader { } #endif // !CAPNP_LITE - template + template < + typename Key2 = ::capnp::AnyPointer, + typename Value2 = ::capnp::AnyPointer> typename Map::Reader asGeneric() { return typename Map::Reader(_reader); } inline bool hasEntries() const; - inline typename ::capnp::List::Entry, ::capnp::Kind::STRUCT>::Reader getEntries() const; + inline typename ::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>::Reader + getEntries() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4288,34 +5248,62 @@ class Map::Reader { template class Map::Builder { -public: + public: typedef Map Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE - template + template < + typename Key2 = ::capnp::AnyPointer, + typename Value2 = ::capnp::AnyPointer> typename Map::Builder asGeneric() { return typename Map::Builder(_builder); } inline bool hasEntries(); - inline typename ::capnp::List::Entry, ::capnp::Kind::STRUCT>::Builder getEntries(); - inline void setEntries(typename ::capnp::List::Entry, ::capnp::Kind::STRUCT>::Reader value); - inline typename ::capnp::List::Entry, ::capnp::Kind::STRUCT>::Builder initEntries(unsigned int size); - inline void adoptEntries(::capnp::Orphan< ::capnp::List::Entry, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List::Entry, ::capnp::Kind::STRUCT>> disownEntries(); - -private: + inline typename ::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>::Builder + getEntries(); + inline void setEntries( + typename ::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>::Reader value); + inline typename ::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>::Builder + initEntries(unsigned int size); + inline void adoptEntries( + ::capnp::Orphan<::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>> + disownEntries(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -4327,14 +5315,17 @@ class Map::Builder { #if !CAPNP_LITE template class Map::Pipeline { -public: + public: typedef Map Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4344,11 +5335,13 @@ class Map::Pipeline { template class Map::Entry::Reader { -public: + public: typedef Entry Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4360,18 +5353,20 @@ class Map::Entry::Reader { } #endif // !CAPNP_LITE - template + template < + typename Key2 = ::capnp::AnyPointer, + typename Value2 = ::capnp::AnyPointer> typename Map::Entry::Reader asMapGeneric() { return typename Map::Entry::Reader(_reader); } inline bool hasKey() const; - inline ::capnp::ReaderFor getKey() const; + inline ::capnp::ReaderFor getKey() const; inline bool hasValue() const; - inline ::capnp::ReaderFor getValue() const; + inline ::capnp::ReaderFor getValue() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4385,43 +5380,56 @@ class Map::Entry::Reader { template class Map::Entry::Builder { -public: + public: typedef Entry Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE - template + template < + typename Key2 = ::capnp::AnyPointer, + typename Value2 = ::capnp::AnyPointer> typename Map::Entry::Builder asMapGeneric() { return typename Map::Entry::Builder(_builder); } inline bool hasKey(); - inline ::capnp::BuilderFor getKey(); - inline void setKey( ::capnp::ReaderFor value); - inline ::capnp::BuilderFor initKey(); - inline ::capnp::BuilderFor initKey(unsigned int size); + inline ::capnp::BuilderFor getKey(); + inline void setKey(::capnp::ReaderFor value); + inline ::capnp::BuilderFor initKey(); + inline ::capnp::BuilderFor initKey(unsigned int size); inline void adoptKey(::capnp::Orphan&& value); inline ::capnp::Orphan disownKey(); inline bool hasValue(); - inline ::capnp::BuilderFor getValue(); - inline void setValue( ::capnp::ReaderFor value); - inline ::capnp::BuilderFor initValue(); - inline ::capnp::BuilderFor initValue(unsigned int size); + inline ::capnp::BuilderFor getValue(); + inline void setValue(::capnp::ReaderFor value); + inline ::capnp::BuilderFor initValue(); + inline ::capnp::BuilderFor initValue(unsigned int size); inline void adoptValue(::capnp::Orphan&& value); inline ::capnp::Orphan disownValue(); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -4433,16 +5441,20 @@ class Map::Entry::Builder { #if !CAPNP_LITE template class Map::Entry::Pipeline { -public: + public: typedef Entry Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } + + inline ::capnp::PipelineFor getKey(); + inline ::capnp::PipelineFor getValue(); - inline ::capnp::PipelineFor getKey(); - inline ::capnp::PipelineFor getValue(); -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4451,11 +5463,13 @@ class Map::Entry::Pipeline { #endif // !CAPNP_LITE class MapEnumeration::Reader { -public: + public: typedef MapEnumeration Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4468,9 +5482,12 @@ class MapEnumeration::Reader { #endif // !CAPNP_LITE inline bool hasEntries() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>::Reader getEntries() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>::Reader + getEntries() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4483,29 +5500,55 @@ class MapEnumeration::Reader { }; class MapEnumeration::Builder { -public: + public: typedef MapEnumeration Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasEntries(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>::Builder getEntries(); - inline void setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>::Builder initEntries(unsigned int size); - inline void adoptEntries(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>> disownEntries(); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>::Builder + getEntries(); + inline void setEntries( + ::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>::Builder + initEntries(unsigned int size); + inline void adoptEntries( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>> + disownEntries(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -4516,14 +5559,17 @@ class MapEnumeration::Builder { #if !CAPNP_LITE class MapEnumeration::Pipeline { -public: + public: typedef MapEnumeration Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4532,11 +5578,13 @@ class MapEnumeration::Pipeline { #endif // !CAPNP_LITE class MapEnumeration::Entry::Reader { -public: + public: typedef Entry Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4549,12 +5597,15 @@ class MapEnumeration::Entry::Reader { #endif // !CAPNP_LITE inline bool hasKey() const; - inline ::capnp::Text::Reader getKey() const; + inline ::capnp::Text::Reader getKey() const; inline bool hasValue() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader getValue() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader + getValue() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4567,36 +5618,60 @@ class MapEnumeration::Entry::Reader { }; class MapEnumeration::Entry::Builder { -public: + public: typedef Entry Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasKey(); - inline ::capnp::Text::Builder getKey(); - inline void setKey( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initKey(unsigned int size); - inline void adoptKey(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownKey(); + inline ::capnp::Text::Builder getKey(); + inline void setKey(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initKey(unsigned int size); + inline void adoptKey(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownKey(); inline bool hasValue(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder getValue(); - inline void setValue( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder initValue(unsigned int size); - inline void adoptValue(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> disownValue(); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder + getValue(); + inline void setValue(::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder + initValue(unsigned int size); + inline void adoptValue(::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>> + disownValue(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -4607,14 +5682,17 @@ class MapEnumeration::Entry::Builder { #if !CAPNP_LITE class MapEnumeration::Entry::Pipeline { -public: + public: typedef Entry Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4623,11 +5701,13 @@ class MapEnumeration::Entry::Pipeline { #endif // !CAPNP_LITE class MapUInt32::Reader { -public: + public: typedef MapUInt32 Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4640,9 +5720,12 @@ class MapUInt32::Reader { #endif // !CAPNP_LITE inline bool hasEntries() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>::Reader getEntries() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>::Reader + getEntries() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4655,29 +5738,54 @@ class MapUInt32::Reader { }; class MapUInt32::Builder { -public: + public: typedef MapUInt32 Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasEntries(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>::Builder getEntries(); - inline void setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>::Builder initEntries(unsigned int size); - inline void adoptEntries(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>> disownEntries(); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>::Builder + getEntries(); + inline void setEntries(::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>::Builder + initEntries(unsigned int size); + inline void adoptEntries( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>> + disownEntries(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -4688,14 +5796,17 @@ class MapUInt32::Builder { #if !CAPNP_LITE class MapUInt32::Pipeline { -public: + public: typedef MapUInt32 Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4704,11 +5815,13 @@ class MapUInt32::Pipeline { #endif // !CAPNP_LITE class MapUInt32::Entry::Reader { -public: + public: typedef Entry Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4721,11 +5834,11 @@ class MapUInt32::Entry::Reader { #endif // !CAPNP_LITE inline bool hasKey() const; - inline ::capnp::Text::Reader getKey() const; + inline ::capnp::Text::Reader getKey() const; - inline ::uint32_t getValue() const; + inline ::uint32_t getValue() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4738,32 +5851,43 @@ class MapUInt32::Entry::Reader { }; class MapUInt32::Entry::Builder { -public: + public: typedef Entry Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasKey(); - inline ::capnp::Text::Builder getKey(); - inline void setKey( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initKey(unsigned int size); - inline void adoptKey(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownKey(); + inline ::capnp::Text::Builder getKey(); + inline void setKey(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initKey(unsigned int size); + inline void adoptKey(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownKey(); - inline ::uint32_t getValue(); - inline void setValue( ::uint32_t value); + inline ::uint32_t getValue(); + inline void setValue(::uint32_t value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -4774,14 +5898,17 @@ class MapUInt32::Entry::Builder { #if !CAPNP_LITE class MapUInt32::Entry::Pipeline { -public: + public: typedef Entry Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4790,11 +5917,13 @@ class MapUInt32::Entry::Pipeline { #endif // !CAPNP_LITE class MapInt64::Reader { -public: + public: typedef MapInt64 Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4807,9 +5936,12 @@ class MapInt64::Reader { #endif // !CAPNP_LITE inline bool hasEntries() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>::Reader getEntries() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>::Reader + getEntries() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4822,29 +5954,54 @@ class MapInt64::Reader { }; class MapInt64::Builder { -public: + public: typedef MapInt64 Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasEntries(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>::Builder getEntries(); - inline void setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>::Builder initEntries(unsigned int size); - inline void adoptEntries(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>> disownEntries(); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>::Builder + getEntries(); + inline void setEntries(::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>::Builder + initEntries(unsigned int size); + inline void adoptEntries( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>> + disownEntries(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -4855,14 +6012,17 @@ class MapInt64::Builder { #if !CAPNP_LITE class MapInt64::Pipeline { -public: + public: typedef MapInt64 Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4871,11 +6031,13 @@ class MapInt64::Pipeline { #endif // !CAPNP_LITE class MapInt64::Entry::Reader { -public: + public: typedef Entry Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4888,11 +6050,11 @@ class MapInt64::Entry::Reader { #endif // !CAPNP_LITE inline bool hasKey() const; - inline ::capnp::Text::Reader getKey() const; + inline ::capnp::Text::Reader getKey() const; - inline ::int64_t getValue() const; + inline ::int64_t getValue() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4905,32 +6067,43 @@ class MapInt64::Entry::Reader { }; class MapInt64::Entry::Builder { -public: + public: typedef Entry Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasKey(); - inline ::capnp::Text::Builder getKey(); - inline void setKey( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initKey(unsigned int size); - inline void adoptKey(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownKey(); + inline ::capnp::Text::Builder getKey(); + inline void setKey(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initKey(unsigned int size); + inline void adoptKey(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownKey(); - inline ::int64_t getValue(); - inline void setValue( ::int64_t value); + inline ::int64_t getValue(); + inline void setValue(::int64_t value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -4941,14 +6114,17 @@ class MapInt64::Entry::Builder { #if !CAPNP_LITE class MapInt64::Entry::Pipeline { -public: + public: typedef Entry Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -4957,11 +6133,13 @@ class MapInt64::Entry::Pipeline { #endif // !CAPNP_LITE class MapUInt64::Reader { -public: + public: typedef MapUInt64 Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -4974,9 +6152,12 @@ class MapUInt64::Reader { #endif // !CAPNP_LITE inline bool hasEntries() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>::Reader getEntries() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>::Reader + getEntries() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -4989,29 +6170,54 @@ class MapUInt64::Reader { }; class MapUInt64::Builder { -public: + public: typedef MapUInt64 Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasEntries(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>::Builder getEntries(); - inline void setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>::Builder initEntries(unsigned int size); - inline void adoptEntries(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>> disownEntries(); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>::Builder + getEntries(); + inline void setEntries(::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>::Builder + initEntries(unsigned int size); + inline void adoptEntries( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>> + disownEntries(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5022,14 +6228,17 @@ class MapUInt64::Builder { #if !CAPNP_LITE class MapUInt64::Pipeline { -public: + public: typedef MapUInt64 Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5038,11 +6247,13 @@ class MapUInt64::Pipeline { #endif // !CAPNP_LITE class MapUInt64::Entry::Reader { -public: + public: typedef Entry Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -5055,11 +6266,11 @@ class MapUInt64::Entry::Reader { #endif // !CAPNP_LITE inline bool hasKey() const; - inline ::capnp::Text::Reader getKey() const; + inline ::capnp::Text::Reader getKey() const; - inline ::uint64_t getValue() const; + inline ::uint64_t getValue() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -5072,32 +6283,43 @@ class MapUInt64::Entry::Reader { }; class MapUInt64::Entry::Builder { -public: + public: typedef Entry Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasKey(); - inline ::capnp::Text::Builder getKey(); - inline void setKey( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initKey(unsigned int size); - inline void adoptKey(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownKey(); + inline ::capnp::Text::Builder getKey(); + inline void setKey(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initKey(unsigned int size); + inline void adoptKey(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownKey(); - inline ::uint64_t getValue(); - inline void setValue( ::uint64_t value); + inline ::uint64_t getValue(); + inline void setValue(::uint64_t value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5108,14 +6330,17 @@ class MapUInt64::Entry::Builder { #if !CAPNP_LITE class MapUInt64::Entry::Pipeline { -public: + public: typedef Entry Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5124,11 +6349,13 @@ class MapUInt64::Entry::Pipeline { #endif // !CAPNP_LITE class MapFloat64::Reader { -public: + public: typedef MapFloat64 Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -5141,9 +6368,12 @@ class MapFloat64::Reader { #endif // !CAPNP_LITE inline bool hasEntries() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>::Reader getEntries() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>::Reader + getEntries() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -5156,29 +6386,54 @@ class MapFloat64::Reader { }; class MapFloat64::Builder { -public: + public: typedef MapFloat64 Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasEntries(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>::Builder getEntries(); - inline void setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>::Builder initEntries(unsigned int size); - inline void adoptEntries(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>> disownEntries(); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>::Builder + getEntries(); + inline void setEntries(::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>::Builder + initEntries(unsigned int size); + inline void adoptEntries( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>> + disownEntries(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5189,14 +6444,17 @@ class MapFloat64::Builder { #if !CAPNP_LITE class MapFloat64::Pipeline { -public: + public: typedef MapFloat64 Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5205,11 +6463,13 @@ class MapFloat64::Pipeline { #endif // !CAPNP_LITE class MapFloat64::Entry::Reader { -public: + public: typedef Entry Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -5222,11 +6482,11 @@ class MapFloat64::Entry::Reader { #endif // !CAPNP_LITE inline bool hasKey() const; - inline ::capnp::Text::Reader getKey() const; + inline ::capnp::Text::Reader getKey() const; inline double getValue() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -5239,32 +6499,43 @@ class MapFloat64::Entry::Reader { }; class MapFloat64::Entry::Builder { -public: + public: typedef Entry Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasKey(); - inline ::capnp::Text::Builder getKey(); - inline void setKey( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initKey(unsigned int size); - inline void adoptKey(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownKey(); + inline ::capnp::Text::Builder getKey(); + inline void setKey(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initKey(unsigned int size); + inline void adoptKey(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownKey(); inline double getValue(); inline void setValue(double value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5275,14 +6546,17 @@ class MapFloat64::Entry::Builder { #if !CAPNP_LITE class MapFloat64::Entry::Pipeline { -public: + public: typedef Entry Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5291,11 +6565,13 @@ class MapFloat64::Entry::Pipeline { #endif // !CAPNP_LITE class Stats::Reader { -public: + public: typedef Stats Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -5308,12 +6584,14 @@ class Stats::Reader { #endif // !CAPNP_LITE inline bool hasTimers() const; - inline ::tiledb::sm::serialization::capnp::MapFloat64::Reader getTimers() const; + inline ::tiledb::sm::serialization::capnp::MapFloat64::Reader getTimers() + const; inline bool hasCounters() const; - inline ::tiledb::sm::serialization::capnp::MapUInt64::Reader getCounters() const; + inline ::tiledb::sm::serialization::capnp::MapUInt64::Reader getCounters() + const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -5326,36 +6604,53 @@ class Stats::Reader { }; class Stats::Builder { -public: + public: typedef Stats Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasTimers(); - inline ::tiledb::sm::serialization::capnp::MapFloat64::Builder getTimers(); - inline void setTimers( ::tiledb::sm::serialization::capnp::MapFloat64::Reader value); - inline ::tiledb::sm::serialization::capnp::MapFloat64::Builder initTimers(); - inline void adoptTimers(::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapFloat64>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapFloat64> disownTimers(); + inline ::tiledb::sm::serialization::capnp::MapFloat64::Builder getTimers(); + inline void setTimers( + ::tiledb::sm::serialization::capnp::MapFloat64::Reader value); + inline ::tiledb::sm::serialization::capnp::MapFloat64::Builder initTimers(); + inline void adoptTimers( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapFloat64>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapFloat64> + disownTimers(); inline bool hasCounters(); - inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder getCounters(); - inline void setCounters( ::tiledb::sm::serialization::capnp::MapUInt64::Reader value); - inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder initCounters(); - inline void adoptCounters(::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapUInt64>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapUInt64> disownCounters(); - -private: + inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder getCounters(); + inline void setCounters( + ::tiledb::sm::serialization::capnp::MapUInt64::Reader value); + inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder initCounters(); + inline void adoptCounters( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapUInt64>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapUInt64> + disownCounters(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5366,16 +6661,20 @@ class Stats::Builder { #if !CAPNP_LITE class Stats::Pipeline { -public: + public: typedef Stats Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::MapFloat64::Pipeline getTimers(); - inline ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline getCounters(); -private: + inline ::tiledb::sm::serialization::capnp::MapFloat64::Pipeline getTimers(); + inline ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline getCounters(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5384,11 +6683,13 @@ class Stats::Pipeline { #endif // !CAPNP_LITE class UnorderedWriterState::Reader { -public: + public: typedef UnorderedWriterState Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -5403,15 +6704,18 @@ class UnorderedWriterState::Reader { inline bool getIsCoordsPass() const; inline bool hasCellPos() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getCellPos() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getCellPos() const; inline bool hasCoordDups() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getCoordDups() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getCoordDups() const; inline bool hasFragMeta() const; - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader getFragMeta() const; + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader + getFragMeta() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -5424,48 +6728,77 @@ class UnorderedWriterState::Reader { }; class UnorderedWriterState::Builder { -public: + public: typedef UnorderedWriterState Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool getIsCoordsPass(); inline void setIsCoordsPass(bool value); inline bool hasCellPos(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getCellPos(); - inline void setCellPos( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setCellPos(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initCellPos(unsigned int size); - inline void adoptCellPos(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownCellPos(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getCellPos(); + inline void setCellPos( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setCellPos(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initCellPos(unsigned int size); + inline void adoptCellPos( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownCellPos(); inline bool hasCoordDups(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getCoordDups(); - inline void setCoordDups( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setCoordDups(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initCoordDups(unsigned int size); - inline void adoptCoordDups(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownCoordDups(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getCoordDups(); + inline void setCoordDups( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setCoordDups(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initCoordDups(unsigned int size); + inline void adoptCoordDups( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownCoordDups(); inline bool hasFragMeta(); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder getFragMeta(); - inline void setFragMeta( ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder initFragMeta(); - inline void adoptFragMeta(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata> disownFragMeta(); - -private: + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder + getFragMeta(); + inline void setFragMeta( + ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value); + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder + initFragMeta(); + inline void adoptFragMeta( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata> + disownFragMeta(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5476,15 +6809,20 @@ class UnorderedWriterState::Builder { #if !CAPNP_LITE class UnorderedWriterState::Pipeline { -public: + public: typedef UnorderedWriterState Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline + getFragMeta(); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline getFragMeta(); -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5493,11 +6831,13 @@ class UnorderedWriterState::Pipeline { #endif // !CAPNP_LITE class Writer::Reader { -public: + public: typedef Writer Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -5516,21 +6856,25 @@ class Writer::Reader { inline bool getDedupCoords() const; inline bool hasSubarray() const; - inline ::tiledb::sm::serialization::capnp::DomainArray::Reader getSubarray() const; + inline ::tiledb::sm::serialization::capnp::DomainArray::Reader getSubarray() + const; inline bool hasSubarrayRanges() const; - inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarrayRanges() const; + inline ::tiledb::sm::serialization::capnp::Subarray::Reader + getSubarrayRanges() const; inline bool hasStats() const; - inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; + inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; inline bool hasGlobalWriteStateV1() const; - inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Reader getGlobalWriteStateV1() const; + inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Reader + getGlobalWriteStateV1() const; inline bool hasUnorderedWriterState() const; - inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Reader getUnorderedWriterState() const; + inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Reader + getUnorderedWriterState() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -5543,19 +6887,30 @@ class Writer::Reader { }; class Writer::Builder { -public: + public: typedef Writer Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool getCheckCoordDups(); @@ -5568,41 +6923,65 @@ class Writer::Builder { inline void setDedupCoords(bool value); inline bool hasSubarray(); - inline ::tiledb::sm::serialization::capnp::DomainArray::Builder getSubarray(); - inline void setSubarray( ::tiledb::sm::serialization::capnp::DomainArray::Reader value); - inline ::tiledb::sm::serialization::capnp::DomainArray::Builder initSubarray(); - inline void adoptSubarray(::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray> disownSubarray(); + inline ::tiledb::sm::serialization::capnp::DomainArray::Builder getSubarray(); + inline void setSubarray( + ::tiledb::sm::serialization::capnp::DomainArray::Reader value); + inline ::tiledb::sm::serialization::capnp::DomainArray::Builder + initSubarray(); + inline void adoptSubarray( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray> + disownSubarray(); inline bool hasSubarrayRanges(); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarrayRanges(); - inline void setSubarrayRanges( ::tiledb::sm::serialization::capnp::Subarray::Reader value); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarrayRanges(); - inline void adoptSubarrayRanges(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> disownSubarrayRanges(); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder + getSubarrayRanges(); + inline void setSubarrayRanges( + ::tiledb::sm::serialization::capnp::Subarray::Reader value); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder + initSubarrayRanges(); + inline void adoptSubarrayRanges( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> + disownSubarrayRanges(); inline bool hasStats(); - inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); - inline void setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value); - inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); - inline void adoptStats(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> disownStats(); + inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); + inline void setStats(::tiledb::sm::serialization::capnp::Stats::Reader value); + inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); + inline void adoptStats( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> + disownStats(); inline bool hasGlobalWriteStateV1(); - inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Builder getGlobalWriteStateV1(); - inline void setGlobalWriteStateV1( ::tiledb::sm::serialization::capnp::GlobalWriteState::Reader value); - inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Builder initGlobalWriteStateV1(); - inline void adoptGlobalWriteStateV1(::capnp::Orphan< ::tiledb::sm::serialization::capnp::GlobalWriteState>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GlobalWriteState> disownGlobalWriteStateV1(); + inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Builder + getGlobalWriteStateV1(); + inline void setGlobalWriteStateV1( + ::tiledb::sm::serialization::capnp::GlobalWriteState::Reader value); + inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Builder + initGlobalWriteStateV1(); + inline void adoptGlobalWriteStateV1( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::GlobalWriteState>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::GlobalWriteState> + disownGlobalWriteStateV1(); inline bool hasUnorderedWriterState(); - inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Builder getUnorderedWriterState(); - inline void setUnorderedWriterState( ::tiledb::sm::serialization::capnp::UnorderedWriterState::Reader value); - inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Builder initUnorderedWriterState(); - inline void adoptUnorderedWriterState(::capnp::Orphan< ::tiledb::sm::serialization::capnp::UnorderedWriterState>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::UnorderedWriterState> disownUnorderedWriterState(); - -private: + inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Builder + getUnorderedWriterState(); + inline void setUnorderedWriterState( + ::tiledb::sm::serialization::capnp::UnorderedWriterState::Reader value); + inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Builder + initUnorderedWriterState(); + inline void adoptUnorderedWriterState( + ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::UnorderedWriterState>&& value); + inline ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::UnorderedWriterState> + disownUnorderedWriterState(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5613,19 +6992,27 @@ class Writer::Builder { #if !CAPNP_LITE class Writer::Pipeline { -public: + public: typedef Writer Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - - inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline getSubarray(); - inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarrayRanges(); - inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); - inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Pipeline getGlobalWriteStateV1(); - inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Pipeline getUnorderedWriterState(); -private: + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline + getSubarray(); + inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline + getSubarrayRanges(); + inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); + inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Pipeline + getGlobalWriteStateV1(); + inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Pipeline + getUnorderedWriterState(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5634,11 +7021,13 @@ class Writer::Pipeline { #endif // !CAPNP_LITE class SubarrayRanges::Reader { -public: + public: typedef SubarrayRanges Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -5651,20 +7040,22 @@ class SubarrayRanges::Reader { #endif // !CAPNP_LITE inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; inline bool getHasDefaultRange() const; inline bool hasBuffer() const; - inline ::capnp::Data::Reader getBuffer() const; + inline ::capnp::Data::Reader getBuffer() const; inline bool hasBufferSizes() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getBufferSizes() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getBufferSizes() const; inline bool hasBufferStartSizes() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getBufferStartSizes() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getBufferStartSizes() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -5677,55 +7068,78 @@ class SubarrayRanges::Reader { }; class SubarrayRanges::Builder { -public: + public: typedef SubarrayRanges Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownType(); inline bool getHasDefaultRange(); inline void setHasDefaultRange(bool value); inline bool hasBuffer(); - inline ::capnp::Data::Builder getBuffer(); - inline void setBuffer( ::capnp::Data::Reader value); - inline ::capnp::Data::Builder initBuffer(unsigned int size); - inline void adoptBuffer(::capnp::Orphan< ::capnp::Data>&& value); - inline ::capnp::Orphan< ::capnp::Data> disownBuffer(); + inline ::capnp::Data::Builder getBuffer(); + inline void setBuffer(::capnp::Data::Reader value); + inline ::capnp::Data::Builder initBuffer(unsigned int size); + inline void adoptBuffer(::capnp::Orphan<::capnp::Data>&& value); + inline ::capnp::Orphan<::capnp::Data> disownBuffer(); inline bool hasBufferSizes(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getBufferSizes(); - inline void setBufferSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setBufferSizes(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initBufferSizes(unsigned int size); - inline void adoptBufferSizes(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownBufferSizes(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getBufferSizes(); + inline void setBufferSizes( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setBufferSizes(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initBufferSizes(unsigned int size); + inline void adoptBufferSizes( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownBufferSizes(); inline bool hasBufferStartSizes(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getBufferStartSizes(); - inline void setBufferStartSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setBufferStartSizes(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initBufferStartSizes(unsigned int size); - inline void adoptBufferStartSizes(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownBufferStartSizes(); - -private: + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getBufferStartSizes(); + inline void setBufferStartSizes( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setBufferStartSizes(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initBufferStartSizes(unsigned int size); + inline void adoptBufferStartSizes( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownBufferStartSizes(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5736,14 +7150,17 @@ class SubarrayRanges::Builder { #if !CAPNP_LITE class SubarrayRanges::Pipeline { -public: + public: typedef SubarrayRanges Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5752,11 +7169,13 @@ class SubarrayRanges::Pipeline { #endif // !CAPNP_LITE class LabelSubarrayRanges::Reader { -public: + public: typedef LabelSubarrayRanges Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -5768,15 +7187,16 @@ class LabelSubarrayRanges::Reader { } #endif // !CAPNP_LITE - inline ::uint32_t getDimensionId() const; + inline ::uint32_t getDimensionId() const; inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; inline bool hasRanges() const; - inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Reader getRanges() const; + inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Reader getRanges() + const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -5789,39 +7209,56 @@ class LabelSubarrayRanges::Reader { }; class LabelSubarrayRanges::Builder { -public: + public: typedef LabelSubarrayRanges Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE - inline ::uint32_t getDimensionId(); - inline void setDimensionId( ::uint32_t value); + inline ::uint32_t getDimensionId(); + inline void setDimensionId(::uint32_t value); inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownName(); inline bool hasRanges(); - inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Builder getRanges(); - inline void setRanges( ::tiledb::sm::serialization::capnp::SubarrayRanges::Reader value); - inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Builder initRanges(); - inline void adoptRanges(::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayRanges>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayRanges> disownRanges(); - -private: + inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Builder + getRanges(); + inline void setRanges( + ::tiledb::sm::serialization::capnp::SubarrayRanges::Reader value); + inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Builder + initRanges(); + inline void adoptRanges( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayRanges>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayRanges> + disownRanges(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5832,15 +7269,20 @@ class LabelSubarrayRanges::Builder { #if !CAPNP_LITE class LabelSubarrayRanges::Pipeline { -public: + public: typedef LabelSubarrayRanges Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Pipeline getRanges(); -private: + inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Pipeline + getRanges(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5849,11 +7291,13 @@ class LabelSubarrayRanges::Pipeline { #endif // !CAPNP_LITE class Subarray::Reader { -public: + public: typedef Subarray Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -5866,26 +7310,36 @@ class Subarray::Reader { #endif // !CAPNP_LITE inline bool hasLayout() const; - inline ::capnp::Text::Reader getLayout() const; + inline ::capnp::Text::Reader getLayout() const; inline bool hasRanges() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Reader getRanges() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>::Reader + getRanges() const; inline bool hasStats() const; - inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; + inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; inline bool hasRelevantFragments() const; - inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader getRelevantFragments() const; + inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader + getRelevantFragments() const; inline bool hasLabelRanges() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>::Reader getLabelRanges() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>::Reader + getLabelRanges() const; inline bool hasAttributeRanges() const; - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Reader getAttributeRanges() const; + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>::Reader + getAttributeRanges() const; inline bool getCoalesceRanges() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -5898,68 +7352,131 @@ class Subarray::Reader { }; class Subarray::Builder { -public: + public: typedef Subarray Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasLayout(); - inline ::capnp::Text::Builder getLayout(); - inline void setLayout( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initLayout(unsigned int size); - inline void adoptLayout(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownLayout(); + inline ::capnp::Text::Builder getLayout(); + inline void setLayout(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initLayout(unsigned int size); + inline void adoptLayout(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownLayout(); inline bool hasRanges(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Builder getRanges(); - inline void setRanges( ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Builder initRanges(unsigned int size); - inline void adoptRanges(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>> disownRanges(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>::Builder + getRanges(); + inline void setRanges(::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>::Builder + initRanges(unsigned int size); + inline void adoptRanges( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>> + disownRanges(); inline bool hasStats(); - inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); - inline void setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value); - inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); - inline void adoptStats(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> disownStats(); + inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); + inline void setStats(::tiledb::sm::serialization::capnp::Stats::Reader value); + inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); + inline void adoptStats( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> + disownStats(); inline bool hasRelevantFragments(); - inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder getRelevantFragments(); - inline void setRelevantFragments( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setRelevantFragments(::kj::ArrayPtr value); - inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder initRelevantFragments(unsigned int size); - inline void adoptRelevantFragments(::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> disownRelevantFragments(); + inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder + getRelevantFragments(); + inline void setRelevantFragments( + ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setRelevantFragments(::kj::ArrayPtr value); + inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder + initRelevantFragments(unsigned int size); + inline void adoptRelevantFragments( + ::capnp::Orphan<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>> + disownRelevantFragments(); inline bool hasLabelRanges(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>::Builder getLabelRanges(); - inline void setLabelRanges( ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>::Builder initLabelRanges(unsigned int size); - inline void adoptLabelRanges(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>> disownLabelRanges(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>::Builder + getLabelRanges(); + inline void setLabelRanges( + ::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>::Builder + initLabelRanges(unsigned int size); + inline void adoptLabelRanges( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>> + disownLabelRanges(); inline bool hasAttributeRanges(); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Builder getAttributeRanges(); - inline void setAttributeRanges( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Reader value); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Builder initAttributeRanges(); - inline void adoptAttributeRanges(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>> disownAttributeRanges(); + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>::Builder + getAttributeRanges(); + inline void setAttributeRanges( + ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>::Reader value); + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>::Builder + initAttributeRanges(); + inline void adoptAttributeRanges( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>> + disownAttributeRanges(); inline bool getCoalesceRanges(); inline void setCoalesceRanges(bool value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -5970,16 +7487,23 @@ class Subarray::Builder { #if !CAPNP_LITE class Subarray::Pipeline { -public: + public: typedef Subarray Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Pipeline getAttributeRanges(); -private: + inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>::Pipeline + getAttributeRanges(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -5988,11 +7512,13 @@ class Subarray::Pipeline { #endif // !CAPNP_LITE class SubarrayPartitioner::Reader { -public: + public: typedef SubarrayPartitioner Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -6005,27 +7531,34 @@ class SubarrayPartitioner::Reader { #endif // !CAPNP_LITE inline bool hasSubarray() const; - inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarray() const; + inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarray() + const; inline bool hasBudget() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>::Reader getBudget() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>::Reader + getBudget() const; inline bool hasCurrent() const; - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Reader getCurrent() const; + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner:: + PartitionInfo::Reader + getCurrent() const; inline bool hasState() const; - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Reader getState() const; + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Reader + getState() const; - inline ::uint64_t getMemoryBudget() const; + inline ::uint64_t getMemoryBudget() const; - inline ::uint64_t getMemoryBudgetVar() const; + inline ::uint64_t getMemoryBudgetVar() const; - inline ::uint64_t getMemoryBudgetValidity() const; + inline ::uint64_t getMemoryBudgetValidity() const; inline bool hasStats() const; - inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; + inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -6038,66 +7571,114 @@ class SubarrayPartitioner::Reader { }; class SubarrayPartitioner::Builder { -public: + public: typedef SubarrayPartitioner Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasSubarray(); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarray(); - inline void setSubarray( ::tiledb::sm::serialization::capnp::Subarray::Reader value); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarray(); - inline void adoptSubarray(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> disownSubarray(); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarray(); + inline void setSubarray( + ::tiledb::sm::serialization::capnp::Subarray::Reader value); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarray(); + inline void adoptSubarray( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> + disownSubarray(); inline bool hasBudget(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>::Builder getBudget(); - inline void setBudget( ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>::Builder initBudget(unsigned int size); - inline void adoptBudget(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>> disownBudget(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>::Builder + getBudget(); + inline void setBudget(::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>::Builder + initBudget(unsigned int size); + inline void adoptBudget( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>> + disownBudget(); inline bool hasCurrent(); - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Builder getCurrent(); - inline void setCurrent( ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Reader value); - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Builder initCurrent(); - inline void adoptCurrent(::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo> disownCurrent(); + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner:: + PartitionInfo::Builder + getCurrent(); + inline void setCurrent(::tiledb::sm::serialization::capnp:: + SubarrayPartitioner::PartitionInfo::Reader value); + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner:: + PartitionInfo::Builder + initCurrent(); + inline void adoptCurrent( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayPartitioner:: + PartitionInfo>&& value); + inline ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo> + disownCurrent(); inline bool hasState(); - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Builder getState(); - inline void setState( ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Reader value); - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Builder initState(); - inline void adoptState(::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State> disownState(); - - inline ::uint64_t getMemoryBudget(); - inline void setMemoryBudget( ::uint64_t value); - - inline ::uint64_t getMemoryBudgetVar(); - inline void setMemoryBudgetVar( ::uint64_t value); - - inline ::uint64_t getMemoryBudgetValidity(); - inline void setMemoryBudgetValidity( ::uint64_t value); + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Builder + getState(); + inline void setState( + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Reader + value); + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Builder + initState(); + inline void adoptState( + ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>&& + value); + inline ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State> + disownState(); + + inline ::uint64_t getMemoryBudget(); + inline void setMemoryBudget(::uint64_t value); + + inline ::uint64_t getMemoryBudgetVar(); + inline void setMemoryBudgetVar(::uint64_t value); + + inline ::uint64_t getMemoryBudgetValidity(); + inline void setMemoryBudgetValidity(::uint64_t value); inline bool hasStats(); - inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); - inline void setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value); - inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); - inline void adoptStats(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> disownStats(); - -private: + inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); + inline void setStats(::tiledb::sm::serialization::capnp::Stats::Reader value); + inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); + inline void adoptStats( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> + disownStats(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -6108,18 +7689,26 @@ class SubarrayPartitioner::Builder { #if !CAPNP_LITE class SubarrayPartitioner::Pipeline { -public: + public: typedef SubarrayPartitioner Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarray(); - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Pipeline getCurrent(); - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Pipeline getState(); - inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); -private: + inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarray(); + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner:: + PartitionInfo::Pipeline + getCurrent(); + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State:: + Pipeline + getState(); + inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -6128,11 +7717,13 @@ class SubarrayPartitioner::Pipeline { #endif // !CAPNP_LITE class SubarrayPartitioner::PartitionInfo::Reader { -public: + public: typedef PartitionInfo Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -6145,15 +7736,16 @@ class SubarrayPartitioner::PartitionInfo::Reader { #endif // !CAPNP_LITE inline bool hasSubarray() const; - inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarray() const; + inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarray() + const; - inline ::uint64_t getStart() const; + inline ::uint64_t getStart() const; - inline ::uint64_t getEnd() const; + inline ::uint64_t getEnd() const; inline bool getSplitMultiRange() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -6166,38 +7758,52 @@ class SubarrayPartitioner::PartitionInfo::Reader { }; class SubarrayPartitioner::PartitionInfo::Builder { -public: + public: typedef PartitionInfo Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasSubarray(); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarray(); - inline void setSubarray( ::tiledb::sm::serialization::capnp::Subarray::Reader value); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarray(); - inline void adoptSubarray(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> disownSubarray(); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarray(); + inline void setSubarray( + ::tiledb::sm::serialization::capnp::Subarray::Reader value); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarray(); + inline void adoptSubarray( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> + disownSubarray(); - inline ::uint64_t getStart(); - inline void setStart( ::uint64_t value); + inline ::uint64_t getStart(); + inline void setStart(::uint64_t value); - inline ::uint64_t getEnd(); - inline void setEnd( ::uint64_t value); + inline ::uint64_t getEnd(); + inline void setEnd(::uint64_t value); inline bool getSplitMultiRange(); inline void setSplitMultiRange(bool value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -6208,15 +7814,19 @@ class SubarrayPartitioner::PartitionInfo::Builder { #if !CAPNP_LITE class SubarrayPartitioner::PartitionInfo::Pipeline { -public: + public: typedef PartitionInfo Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarray(); -private: + inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarray(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -6225,11 +7835,13 @@ class SubarrayPartitioner::PartitionInfo::Pipeline { #endif // !CAPNP_LITE class SubarrayPartitioner::State::Reader { -public: + public: typedef State Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -6241,17 +7853,23 @@ class SubarrayPartitioner::State::Reader { } #endif // !CAPNP_LITE - inline ::uint64_t getStart() const; + inline ::uint64_t getStart() const; - inline ::uint64_t getEnd() const; + inline ::uint64_t getEnd() const; inline bool hasSingleRange() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Reader getSingleRange() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>::Reader + getSingleRange() const; inline bool hasMultiRange() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Reader getMultiRange() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>::Reader + getMultiRange() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -6264,42 +7882,79 @@ class SubarrayPartitioner::State::Reader { }; class SubarrayPartitioner::State::Builder { -public: + public: typedef State Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE - inline ::uint64_t getStart(); - inline void setStart( ::uint64_t value); + inline ::uint64_t getStart(); + inline void setStart(::uint64_t value); - inline ::uint64_t getEnd(); - inline void setEnd( ::uint64_t value); + inline ::uint64_t getEnd(); + inline void setEnd(::uint64_t value); inline bool hasSingleRange(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Builder getSingleRange(); - inline void setSingleRange( ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Builder initSingleRange(unsigned int size); - inline void adoptSingleRange(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>> disownSingleRange(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>::Builder + getSingleRange(); + inline void setSingleRange(::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>::Builder + initSingleRange(unsigned int size); + inline void adoptSingleRange(::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>> + disownSingleRange(); inline bool hasMultiRange(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Builder getMultiRange(); - inline void setMultiRange( ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Builder initMultiRange(unsigned int size); - inline void adoptMultiRange(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>> disownMultiRange(); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>::Builder + getMultiRange(); + inline void setMultiRange(::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>::Builder + initMultiRange(unsigned int size); + inline void adoptMultiRange(::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>> + disownMultiRange(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -6310,14 +7965,17 @@ class SubarrayPartitioner::State::Builder { #if !CAPNP_LITE class SubarrayPartitioner::State::Pipeline { -public: + public: typedef State Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -6326,11 +7984,13 @@ class SubarrayPartitioner::State::Pipeline { #endif // !CAPNP_LITE class ReadState::Reader { -public: + public: typedef ReadState Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -6349,9 +8009,10 @@ class ReadState::Reader { inline bool getInitialized() const; inline bool hasSubarrayPartitioner() const; - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Reader getSubarrayPartitioner() const; + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Reader + getSubarrayPartitioner() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -6364,19 +8025,30 @@ class ReadState::Reader { }; class ReadState::Builder { -public: + public: typedef ReadState Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool getOverflowed(); @@ -6389,13 +8061,20 @@ class ReadState::Builder { inline void setInitialized(bool value); inline bool hasSubarrayPartitioner(); - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Builder getSubarrayPartitioner(); - inline void setSubarrayPartitioner( ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Reader value); - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Builder initSubarrayPartitioner(); - inline void adoptSubarrayPartitioner(::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner> disownSubarrayPartitioner(); - -private: + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Builder + getSubarrayPartitioner(); + inline void setSubarrayPartitioner( + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Reader value); + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Builder + initSubarrayPartitioner(); + inline void adoptSubarrayPartitioner( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayPartitioner>&& + value); + inline ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner> + disownSubarrayPartitioner(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -6406,15 +8085,20 @@ class ReadState::Builder { #if !CAPNP_LITE class ReadState::Pipeline { -public: + public: typedef ReadState Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Pipeline + getSubarrayPartitioner(); - inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Pipeline getSubarrayPartitioner(); -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -6423,11 +8107,13 @@ class ReadState::Pipeline { #endif // !CAPNP_LITE class ConditionClause::Reader { -public: + public: typedef ConditionClause Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -6440,17 +8126,17 @@ class ConditionClause::Reader { #endif // !CAPNP_LITE inline bool hasFieldName() const; - inline ::capnp::Text::Reader getFieldName() const; + inline ::capnp::Text::Reader getFieldName() const; inline bool hasValue() const; - inline ::capnp::Data::Reader getValue() const; + inline ::capnp::Data::Reader getValue() const; inline bool hasOp() const; - inline ::capnp::Text::Reader getOp() const; + inline ::capnp::Text::Reader getOp() const; inline bool getUseEnumeration() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -6463,46 +8149,57 @@ class ConditionClause::Reader { }; class ConditionClause::Builder { -public: + public: typedef ConditionClause Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasFieldName(); - inline ::capnp::Text::Builder getFieldName(); - inline void setFieldName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initFieldName(unsigned int size); - inline void adoptFieldName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownFieldName(); + inline ::capnp::Text::Builder getFieldName(); + inline void setFieldName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initFieldName(unsigned int size); + inline void adoptFieldName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownFieldName(); inline bool hasValue(); - inline ::capnp::Data::Builder getValue(); - inline void setValue( ::capnp::Data::Reader value); - inline ::capnp::Data::Builder initValue(unsigned int size); - inline void adoptValue(::capnp::Orphan< ::capnp::Data>&& value); - inline ::capnp::Orphan< ::capnp::Data> disownValue(); + inline ::capnp::Data::Builder getValue(); + inline void setValue(::capnp::Data::Reader value); + inline ::capnp::Data::Builder initValue(unsigned int size); + inline void adoptValue(::capnp::Orphan<::capnp::Data>&& value); + inline ::capnp::Orphan<::capnp::Data> disownValue(); inline bool hasOp(); - inline ::capnp::Text::Builder getOp(); - inline void setOp( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initOp(unsigned int size); - inline void adoptOp(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownOp(); + inline ::capnp::Text::Builder getOp(); + inline void setOp(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initOp(unsigned int size); + inline void adoptOp(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownOp(); inline bool getUseEnumeration(); inline void setUseEnumeration(bool value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -6513,14 +8210,17 @@ class ConditionClause::Builder { #if !CAPNP_LITE class ConditionClause::Pipeline { -public: + public: typedef ConditionClause Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -6529,11 +8229,13 @@ class ConditionClause::Pipeline { #endif // !CAPNP_LITE class ASTNode::Reader { -public: + public: typedef ASTNode Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -6548,26 +8250,29 @@ class ASTNode::Reader { inline bool getIsExpression() const; inline bool hasFieldName() const; - inline ::capnp::Text::Reader getFieldName() const; + inline ::capnp::Text::Reader getFieldName() const; inline bool hasValue() const; - inline ::capnp::Data::Reader getValue() const; + inline ::capnp::Data::Reader getValue() const; inline bool hasOp() const; - inline ::capnp::Text::Reader getOp() const; + inline ::capnp::Text::Reader getOp() const; inline bool hasChildren() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>::Reader getChildren() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>::Reader + getChildren() const; inline bool hasCombinationOp() const; - inline ::capnp::Text::Reader getCombinationOp() const; + inline ::capnp::Text::Reader getCombinationOp() const; inline bool getUseEnumeration() const; inline bool hasOffsets() const; - inline ::capnp::Data::Reader getOffsets() const; + inline ::capnp::Data::Reader getOffsets() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -6580,70 +8285,94 @@ class ASTNode::Reader { }; class ASTNode::Builder { -public: + public: typedef ASTNode Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool getIsExpression(); inline void setIsExpression(bool value); inline bool hasFieldName(); - inline ::capnp::Text::Builder getFieldName(); - inline void setFieldName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initFieldName(unsigned int size); - inline void adoptFieldName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownFieldName(); + inline ::capnp::Text::Builder getFieldName(); + inline void setFieldName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initFieldName(unsigned int size); + inline void adoptFieldName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownFieldName(); inline bool hasValue(); - inline ::capnp::Data::Builder getValue(); - inline void setValue( ::capnp::Data::Reader value); - inline ::capnp::Data::Builder initValue(unsigned int size); - inline void adoptValue(::capnp::Orphan< ::capnp::Data>&& value); - inline ::capnp::Orphan< ::capnp::Data> disownValue(); + inline ::capnp::Data::Builder getValue(); + inline void setValue(::capnp::Data::Reader value); + inline ::capnp::Data::Builder initValue(unsigned int size); + inline void adoptValue(::capnp::Orphan<::capnp::Data>&& value); + inline ::capnp::Orphan<::capnp::Data> disownValue(); inline bool hasOp(); - inline ::capnp::Text::Builder getOp(); - inline void setOp( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initOp(unsigned int size); - inline void adoptOp(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownOp(); + inline ::capnp::Text::Builder getOp(); + inline void setOp(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initOp(unsigned int size); + inline void adoptOp(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownOp(); inline bool hasChildren(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>::Builder getChildren(); - inline void setChildren( ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>::Builder initChildren(unsigned int size); - inline void adoptChildren(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>> disownChildren(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>::Builder + getChildren(); + inline void setChildren(::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>::Builder + initChildren(unsigned int size); + inline void adoptChildren(::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>> + disownChildren(); inline bool hasCombinationOp(); - inline ::capnp::Text::Builder getCombinationOp(); - inline void setCombinationOp( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initCombinationOp(unsigned int size); - inline void adoptCombinationOp(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownCombinationOp(); + inline ::capnp::Text::Builder getCombinationOp(); + inline void setCombinationOp(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initCombinationOp(unsigned int size); + inline void adoptCombinationOp(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownCombinationOp(); inline bool getUseEnumeration(); inline void setUseEnumeration(bool value); inline bool hasOffsets(); - inline ::capnp::Data::Builder getOffsets(); - inline void setOffsets( ::capnp::Data::Reader value); - inline ::capnp::Data::Builder initOffsets(unsigned int size); - inline void adoptOffsets(::capnp::Orphan< ::capnp::Data>&& value); - inline ::capnp::Orphan< ::capnp::Data> disownOffsets(); + inline ::capnp::Data::Builder getOffsets(); + inline void setOffsets(::capnp::Data::Reader value); + inline ::capnp::Data::Builder initOffsets(unsigned int size); + inline void adoptOffsets(::capnp::Orphan<::capnp::Data>&& value); + inline ::capnp::Orphan<::capnp::Data> disownOffsets(); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -6654,14 +8383,17 @@ class ASTNode::Builder { #if !CAPNP_LITE class ASTNode::Pipeline { -public: + public: typedef ASTNode Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -6670,11 +8402,13 @@ class ASTNode::Pipeline { #endif // !CAPNP_LITE class Condition::Reader { -public: + public: typedef Condition Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -6687,15 +8421,19 @@ class Condition::Reader { #endif // !CAPNP_LITE inline bool hasClauses() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>::Reader getClauses() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>::Reader + getClauses() const; inline bool hasClauseCombinationOps() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getClauseCombinationOps() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getClauseCombinationOps() const; inline bool hasTree() const; - inline ::tiledb::sm::serialization::capnp::ASTNode::Reader getTree() const; + inline ::tiledb::sm::serialization::capnp::ASTNode::Reader getTree() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -6708,44 +8446,79 @@ class Condition::Reader { }; class Condition::Builder { -public: + public: typedef Condition Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasClauses(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>::Builder getClauses(); - inline void setClauses( ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>::Builder initClauses(unsigned int size); - inline void adoptClauses(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>> disownClauses(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>::Builder + getClauses(); + inline void setClauses(::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>::Builder + initClauses(unsigned int size); + inline void adoptClauses( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>> + disownClauses(); inline bool hasClauseCombinationOps(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getClauseCombinationOps(); - inline void setClauseCombinationOps( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setClauseCombinationOps(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initClauseCombinationOps(unsigned int size); - inline void adoptClauseCombinationOps(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownClauseCombinationOps(); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getClauseCombinationOps(); + inline void setClauseCombinationOps( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setClauseCombinationOps( + ::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initClauseCombinationOps(unsigned int size); + inline void adoptClauseCombinationOps( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownClauseCombinationOps(); inline bool hasTree(); - inline ::tiledb::sm::serialization::capnp::ASTNode::Builder getTree(); - inline void setTree( ::tiledb::sm::serialization::capnp::ASTNode::Reader value); - inline ::tiledb::sm::serialization::capnp::ASTNode::Builder initTree(); - inline void adoptTree(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ASTNode>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ASTNode> disownTree(); - -private: + inline ::tiledb::sm::serialization::capnp::ASTNode::Builder getTree(); + inline void setTree( + ::tiledb::sm::serialization::capnp::ASTNode::Reader value); + inline ::tiledb::sm::serialization::capnp::ASTNode::Builder initTree(); + inline void adoptTree( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ASTNode>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ASTNode> + disownTree(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -6756,15 +8529,19 @@ class Condition::Builder { #if !CAPNP_LITE class Condition::Pipeline { -public: + public: typedef Condition Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::ASTNode::Pipeline getTree(); -private: + inline ::tiledb::sm::serialization::capnp::ASTNode::Pipeline getTree(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -6773,11 +8550,13 @@ class Condition::Pipeline { #endif // !CAPNP_LITE class QueryReader::Reader { -public: + public: typedef QueryReader Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -6790,23 +8569,26 @@ class QueryReader::Reader { #endif // !CAPNP_LITE inline bool hasLayout() const; - inline ::capnp::Text::Reader getLayout() const; + inline ::capnp::Text::Reader getLayout() const; inline bool hasSubarray() const; - inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarray() const; + inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarray() + const; inline bool hasReadState() const; - inline ::tiledb::sm::serialization::capnp::ReadState::Reader getReadState() const; + inline ::tiledb::sm::serialization::capnp::ReadState::Reader getReadState() + const; inline bool hasCondition() const; - inline ::tiledb::sm::serialization::capnp::Condition::Reader getCondition() const; + inline ::tiledb::sm::serialization::capnp::Condition::Reader getCondition() + const; inline bool hasStats() const; - inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; + inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; inline bool getDimLabelIncreasing() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -6819,60 +8601,82 @@ class QueryReader::Reader { }; class QueryReader::Builder { -public: + public: typedef QueryReader Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasLayout(); - inline ::capnp::Text::Builder getLayout(); - inline void setLayout( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initLayout(unsigned int size); - inline void adoptLayout(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownLayout(); + inline ::capnp::Text::Builder getLayout(); + inline void setLayout(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initLayout(unsigned int size); + inline void adoptLayout(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownLayout(); inline bool hasSubarray(); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarray(); - inline void setSubarray( ::tiledb::sm::serialization::capnp::Subarray::Reader value); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarray(); - inline void adoptSubarray(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> disownSubarray(); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarray(); + inline void setSubarray( + ::tiledb::sm::serialization::capnp::Subarray::Reader value); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarray(); + inline void adoptSubarray( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> + disownSubarray(); inline bool hasReadState(); - inline ::tiledb::sm::serialization::capnp::ReadState::Builder getReadState(); - inline void setReadState( ::tiledb::sm::serialization::capnp::ReadState::Reader value); - inline ::tiledb::sm::serialization::capnp::ReadState::Builder initReadState(); - inline void adoptReadState(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReadState>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReadState> disownReadState(); + inline ::tiledb::sm::serialization::capnp::ReadState::Builder getReadState(); + inline void setReadState( + ::tiledb::sm::serialization::capnp::ReadState::Reader value); + inline ::tiledb::sm::serialization::capnp::ReadState::Builder initReadState(); + inline void adoptReadState( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReadState>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReadState> + disownReadState(); inline bool hasCondition(); - inline ::tiledb::sm::serialization::capnp::Condition::Builder getCondition(); - inline void setCondition( ::tiledb::sm::serialization::capnp::Condition::Reader value); - inline ::tiledb::sm::serialization::capnp::Condition::Builder initCondition(); - inline void adoptCondition(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition> disownCondition(); + inline ::tiledb::sm::serialization::capnp::Condition::Builder getCondition(); + inline void setCondition( + ::tiledb::sm::serialization::capnp::Condition::Reader value); + inline ::tiledb::sm::serialization::capnp::Condition::Builder initCondition(); + inline void adoptCondition( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition> + disownCondition(); inline bool hasStats(); - inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); - inline void setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value); - inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); - inline void adoptStats(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> disownStats(); + inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); + inline void setStats(::tiledb::sm::serialization::capnp::Stats::Reader value); + inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); + inline void adoptStats( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> + disownStats(); inline bool getDimLabelIncreasing(); inline void setDimLabelIncreasing(bool value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -6883,18 +8687,22 @@ class QueryReader::Builder { #if !CAPNP_LITE class QueryReader::Pipeline { -public: + public: typedef QueryReader Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarray(); - inline ::tiledb::sm::serialization::capnp::ReadState::Pipeline getReadState(); - inline ::tiledb::sm::serialization::capnp::Condition::Pipeline getCondition(); - inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); -private: + inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarray(); + inline ::tiledb::sm::serialization::capnp::ReadState::Pipeline getReadState(); + inline ::tiledb::sm::serialization::capnp::Condition::Pipeline getCondition(); + inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -6903,11 +8711,13 @@ class QueryReader::Pipeline { #endif // !CAPNP_LITE class Delete::Reader { -public: + public: typedef Delete Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -6920,12 +8730,13 @@ class Delete::Reader { #endif // !CAPNP_LITE inline bool hasCondition() const; - inline ::tiledb::sm::serialization::capnp::Condition::Reader getCondition() const; + inline ::tiledb::sm::serialization::capnp::Condition::Reader getCondition() + const; inline bool hasStats() const; - inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; + inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -6938,36 +8749,52 @@ class Delete::Reader { }; class Delete::Builder { -public: + public: typedef Delete Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasCondition(); - inline ::tiledb::sm::serialization::capnp::Condition::Builder getCondition(); - inline void setCondition( ::tiledb::sm::serialization::capnp::Condition::Reader value); - inline ::tiledb::sm::serialization::capnp::Condition::Builder initCondition(); - inline void adoptCondition(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition> disownCondition(); + inline ::tiledb::sm::serialization::capnp::Condition::Builder getCondition(); + inline void setCondition( + ::tiledb::sm::serialization::capnp::Condition::Reader value); + inline ::tiledb::sm::serialization::capnp::Condition::Builder initCondition(); + inline void adoptCondition( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition> + disownCondition(); inline bool hasStats(); - inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); - inline void setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value); - inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); - inline void adoptStats(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> disownStats(); - -private: + inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); + inline void setStats(::tiledb::sm::serialization::capnp::Stats::Reader value); + inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); + inline void adoptStats( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> + disownStats(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -6978,16 +8805,20 @@ class Delete::Builder { #if !CAPNP_LITE class Delete::Pipeline { -public: + public: typedef Delete Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::Condition::Pipeline getCondition(); + inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); - inline ::tiledb::sm::serialization::capnp::Condition::Pipeline getCondition(); - inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -6996,11 +8827,13 @@ class Delete::Pipeline { #endif // !CAPNP_LITE class ResultCellSlab::Reader { -public: + public: typedef ResultCellSlab Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -7012,15 +8845,15 @@ class ResultCellSlab::Reader { } #endif // !CAPNP_LITE - inline ::uint32_t getFragIdx() const; + inline ::uint32_t getFragIdx() const; - inline ::uint64_t getTileIdx() const; + inline ::uint64_t getTileIdx() const; - inline ::uint64_t getStart() const; + inline ::uint64_t getStart() const; - inline ::uint64_t getLength() const; + inline ::uint64_t getLength() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -7033,34 +8866,45 @@ class ResultCellSlab::Reader { }; class ResultCellSlab::Builder { -public: + public: typedef ResultCellSlab Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE - inline ::uint32_t getFragIdx(); - inline void setFragIdx( ::uint32_t value); + inline ::uint32_t getFragIdx(); + inline void setFragIdx(::uint32_t value); - inline ::uint64_t getTileIdx(); - inline void setTileIdx( ::uint64_t value); + inline ::uint64_t getTileIdx(); + inline void setTileIdx(::uint64_t value); - inline ::uint64_t getStart(); - inline void setStart( ::uint64_t value); + inline ::uint64_t getStart(); + inline void setStart(::uint64_t value); - inline ::uint64_t getLength(); - inline void setLength( ::uint64_t value); + inline ::uint64_t getLength(); + inline void setLength(::uint64_t value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -7071,14 +8915,17 @@ class ResultCellSlab::Builder { #if !CAPNP_LITE class ResultCellSlab::Pipeline { -public: + public: typedef ResultCellSlab Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -7087,11 +8934,13 @@ class ResultCellSlab::Pipeline { #endif // !CAPNP_LITE class FragmentIndex::Reader { -public: + public: typedef FragmentIndex Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -7103,11 +8952,11 @@ class FragmentIndex::Reader { } #endif // !CAPNP_LITE - inline ::uint64_t getTileIdx() const; + inline ::uint64_t getTileIdx() const; - inline ::uint64_t getCellIdx() const; + inline ::uint64_t getCellIdx() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -7120,28 +8969,39 @@ class FragmentIndex::Reader { }; class FragmentIndex::Builder { -public: + public: typedef FragmentIndex Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE - inline ::uint64_t getTileIdx(); - inline void setTileIdx( ::uint64_t value); + inline ::uint64_t getTileIdx(); + inline void setTileIdx(::uint64_t value); - inline ::uint64_t getCellIdx(); - inline void setCellIdx( ::uint64_t value); + inline ::uint64_t getCellIdx(); + inline void setCellIdx(::uint64_t value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -7152,14 +9012,17 @@ class FragmentIndex::Builder { #if !CAPNP_LITE class FragmentIndex::Pipeline { -public: + public: typedef FragmentIndex Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -7168,11 +9031,13 @@ class FragmentIndex::Pipeline { #endif // !CAPNP_LITE class ReadStateIndex::Reader { -public: + public: typedef ReadStateIndex Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -7185,14 +9050,20 @@ class ReadStateIndex::Reader { #endif // !CAPNP_LITE inline bool hasResultCellSlab() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>::Reader getResultCellSlab() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>::Reader + getResultCellSlab() const; inline bool hasFragTileIdx() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>::Reader getFragTileIdx() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>::Reader + getFragTileIdx() const; inline bool getDoneAddingResultTiles() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -7205,39 +9076,79 @@ class ReadStateIndex::Reader { }; class ReadStateIndex::Builder { -public: + public: typedef ReadStateIndex Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasResultCellSlab(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>::Builder getResultCellSlab(); - inline void setResultCellSlab( ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>::Builder initResultCellSlab(unsigned int size); - inline void adoptResultCellSlab(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>> disownResultCellSlab(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>::Builder + getResultCellSlab(); + inline void setResultCellSlab( + ::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>::Builder + initResultCellSlab(unsigned int size); + inline void adoptResultCellSlab( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>> + disownResultCellSlab(); inline bool hasFragTileIdx(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>::Builder getFragTileIdx(); - inline void setFragTileIdx( ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>::Builder initFragTileIdx(unsigned int size); - inline void adoptFragTileIdx(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>> disownFragTileIdx(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>::Builder + getFragTileIdx(); + inline void setFragTileIdx(::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>::Builder + initFragTileIdx(unsigned int size); + inline void adoptFragTileIdx( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>> + disownFragTileIdx(); inline bool getDoneAddingResultTiles(); inline void setDoneAddingResultTiles(bool value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -7248,14 +9159,17 @@ class ReadStateIndex::Builder { #if !CAPNP_LITE class ReadStateIndex::Pipeline { -public: + public: typedef ReadStateIndex Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -7264,11 +9178,13 @@ class ReadStateIndex::Pipeline { #endif // !CAPNP_LITE class PreprocessTileOrder::Reader { -public: + public: typedef PreprocessTileOrder Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -7280,9 +9196,9 @@ class PreprocessTileOrder::Reader { } #endif // !CAPNP_LITE - inline ::uint64_t getCursor() const; + inline ::uint64_t getCursor() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -7295,25 +9211,36 @@ class PreprocessTileOrder::Reader { }; class PreprocessTileOrder::Builder { -public: + public: typedef PreprocessTileOrder Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE - inline ::uint64_t getCursor(); - inline void setCursor( ::uint64_t value); + inline ::uint64_t getCursor(); + inline void setCursor(::uint64_t value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -7324,14 +9251,17 @@ class PreprocessTileOrder::Builder { #if !CAPNP_LITE class PreprocessTileOrder::Pipeline { -public: + public: typedef PreprocessTileOrder Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -7340,11 +9270,13 @@ class PreprocessTileOrder::Pipeline { #endif // !CAPNP_LITE class ReaderIndex::Reader { -public: + public: typedef ReaderIndex Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -7357,24 +9289,28 @@ class ReaderIndex::Reader { #endif // !CAPNP_LITE inline bool hasLayout() const; - inline ::capnp::Text::Reader getLayout() const; + inline ::capnp::Text::Reader getLayout() const; inline bool hasSubarray() const; - inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarray() const; + inline ::tiledb::sm::serialization::capnp::Subarray::Reader getSubarray() + const; inline bool hasReadState() const; - inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Reader getReadState() const; + inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Reader + getReadState() const; inline bool hasCondition() const; - inline ::tiledb::sm::serialization::capnp::Condition::Reader getCondition() const; + inline ::tiledb::sm::serialization::capnp::Condition::Reader getCondition() + const; inline bool hasStats() const; - inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; + inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; inline bool hasPreprocess() const; - inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Reader getPreprocess() const; + inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Reader + getPreprocess() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -7387,64 +9323,96 @@ class ReaderIndex::Reader { }; class ReaderIndex::Builder { -public: + public: typedef ReaderIndex Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasLayout(); - inline ::capnp::Text::Builder getLayout(); - inline void setLayout( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initLayout(unsigned int size); - inline void adoptLayout(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownLayout(); + inline ::capnp::Text::Builder getLayout(); + inline void setLayout(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initLayout(unsigned int size); + inline void adoptLayout(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownLayout(); inline bool hasSubarray(); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarray(); - inline void setSubarray( ::tiledb::sm::serialization::capnp::Subarray::Reader value); - inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarray(); - inline void adoptSubarray(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> disownSubarray(); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder getSubarray(); + inline void setSubarray( + ::tiledb::sm::serialization::capnp::Subarray::Reader value); + inline ::tiledb::sm::serialization::capnp::Subarray::Builder initSubarray(); + inline void adoptSubarray( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> + disownSubarray(); inline bool hasReadState(); - inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Builder getReadState(); - inline void setReadState( ::tiledb::sm::serialization::capnp::ReadStateIndex::Reader value); - inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Builder initReadState(); - inline void adoptReadState(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReadStateIndex>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReadStateIndex> disownReadState(); + inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Builder + getReadState(); + inline void setReadState( + ::tiledb::sm::serialization::capnp::ReadStateIndex::Reader value); + inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Builder + initReadState(); + inline void adoptReadState( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReadStateIndex>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReadStateIndex> + disownReadState(); inline bool hasCondition(); - inline ::tiledb::sm::serialization::capnp::Condition::Builder getCondition(); - inline void setCondition( ::tiledb::sm::serialization::capnp::Condition::Reader value); - inline ::tiledb::sm::serialization::capnp::Condition::Builder initCondition(); - inline void adoptCondition(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition> disownCondition(); + inline ::tiledb::sm::serialization::capnp::Condition::Builder getCondition(); + inline void setCondition( + ::tiledb::sm::serialization::capnp::Condition::Reader value); + inline ::tiledb::sm::serialization::capnp::Condition::Builder initCondition(); + inline void adoptCondition( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition> + disownCondition(); inline bool hasStats(); - inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); - inline void setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value); - inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); - inline void adoptStats(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> disownStats(); + inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); + inline void setStats(::tiledb::sm::serialization::capnp::Stats::Reader value); + inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); + inline void adoptStats( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> + disownStats(); inline bool hasPreprocess(); - inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Builder getPreprocess(); - inline void setPreprocess( ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Reader value); - inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Builder initPreprocess(); - inline void adoptPreprocess(::capnp::Orphan< ::tiledb::sm::serialization::capnp::PreprocessTileOrder>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::PreprocessTileOrder> disownPreprocess(); - -private: + inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Builder + getPreprocess(); + inline void setPreprocess( + ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Reader value); + inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Builder + initPreprocess(); + inline void adoptPreprocess( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::PreprocessTileOrder>&& + value); + inline ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::PreprocessTileOrder> + disownPreprocess(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -7455,19 +9423,25 @@ class ReaderIndex::Builder { #if !CAPNP_LITE class ReaderIndex::Pipeline { -public: + public: typedef ReaderIndex Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - - inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarray(); - inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Pipeline getReadState(); - inline ::tiledb::sm::serialization::capnp::Condition::Pipeline getCondition(); - inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); - inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Pipeline getPreprocess(); -private: + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline getSubarray(); + inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Pipeline + getReadState(); + inline ::tiledb::sm::serialization::capnp::Condition::Pipeline getCondition(); + inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); + inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Pipeline + getPreprocess(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -7476,11 +9450,13 @@ class ReaderIndex::Pipeline { #endif // !CAPNP_LITE class Query::Reader { -public: + public: typedef Query Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -7493,67 +9469,81 @@ class Query::Reader { #endif // !CAPNP_LITE inline bool hasAttributeBufferHeaders() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>::Reader getAttributeBufferHeaders() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>::Reader + getAttributeBufferHeaders() const; inline bool hasLayout() const; - inline ::capnp::Text::Reader getLayout() const; + inline ::capnp::Text::Reader getLayout() const; inline bool hasStatus() const; - inline ::capnp::Text::Reader getStatus() const; + inline ::capnp::Text::Reader getStatus() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; inline bool hasWriter() const; - inline ::tiledb::sm::serialization::capnp::Writer::Reader getWriter() const; + inline ::tiledb::sm::serialization::capnp::Writer::Reader getWriter() const; inline bool hasReader() const; - inline ::tiledb::sm::serialization::capnp::QueryReader::Reader getReader() const; + inline ::tiledb::sm::serialization::capnp::QueryReader::Reader getReader() + const; inline bool hasArray() const; - inline ::tiledb::sm::serialization::capnp::Array::Reader getArray() const; + inline ::tiledb::sm::serialization::capnp::Array::Reader getArray() const; - inline ::uint64_t getTotalFixedLengthBufferBytes() const; + inline ::uint64_t getTotalFixedLengthBufferBytes() const; - inline ::uint64_t getTotalVarLenBufferBytes() const; + inline ::uint64_t getTotalVarLenBufferBytes() const; - inline ::uint64_t getTotalValidityBufferBytes() const; + inline ::uint64_t getTotalValidityBufferBytes() const; inline bool hasVarOffsetsMode() const; - inline ::capnp::Text::Reader getVarOffsetsMode() const; + inline ::capnp::Text::Reader getVarOffsetsMode() const; inline bool getVarOffsetsAddExtraElement() const; - inline ::int32_t getVarOffsetsBitsize() const; + inline ::int32_t getVarOffsetsBitsize() const; inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasStats() const; - inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; + inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; inline bool hasReaderIndex() const; - inline ::tiledb::sm::serialization::capnp::ReaderIndex::Reader getReaderIndex() const; + inline ::tiledb::sm::serialization::capnp::ReaderIndex::Reader + getReaderIndex() const; inline bool hasDenseReader() const; - inline ::tiledb::sm::serialization::capnp::QueryReader::Reader getDenseReader() const; + inline ::tiledb::sm::serialization::capnp::QueryReader::Reader + getDenseReader() const; inline bool hasDelete() const; - inline ::tiledb::sm::serialization::capnp::Delete::Reader getDelete() const; + inline ::tiledb::sm::serialization::capnp::Delete::Reader getDelete() const; inline bool hasWrittenFragmentInfo() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>::Reader getWrittenFragmentInfo() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>::Reader + getWrittenFragmentInfo() const; inline bool hasWrittenBuffers() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getWrittenBuffers() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getWrittenBuffers() const; inline bool hasOrderedDimLabelReader() const; - inline ::tiledb::sm::serialization::capnp::QueryReader::Reader getOrderedDimLabelReader() const; + inline ::tiledb::sm::serialization::capnp::QueryReader::Reader + getOrderedDimLabelReader() const; inline bool hasChannels() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>::Reader getChannels() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>::Reader + getChannels() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -7566,157 +9556,250 @@ class Query::Reader { }; class Query::Builder { -public: + public: typedef Query Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasAttributeBufferHeaders(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>::Builder getAttributeBufferHeaders(); - inline void setAttributeBufferHeaders( ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>::Builder initAttributeBufferHeaders(unsigned int size); - inline void adoptAttributeBufferHeaders(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>> disownAttributeBufferHeaders(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>::Builder + getAttributeBufferHeaders(); + inline void setAttributeBufferHeaders( + ::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>::Builder + initAttributeBufferHeaders(unsigned int size); + inline void adoptAttributeBufferHeaders( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>> + disownAttributeBufferHeaders(); inline bool hasLayout(); - inline ::capnp::Text::Builder getLayout(); - inline void setLayout( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initLayout(unsigned int size); - inline void adoptLayout(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownLayout(); + inline ::capnp::Text::Builder getLayout(); + inline void setLayout(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initLayout(unsigned int size); + inline void adoptLayout(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownLayout(); inline bool hasStatus(); - inline ::capnp::Text::Builder getStatus(); - inline void setStatus( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initStatus(unsigned int size); - inline void adoptStatus(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownStatus(); + inline ::capnp::Text::Builder getStatus(); + inline void setStatus(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initStatus(unsigned int size); + inline void adoptStatus(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownStatus(); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownType(); inline bool hasWriter(); - inline ::tiledb::sm::serialization::capnp::Writer::Builder getWriter(); - inline void setWriter( ::tiledb::sm::serialization::capnp::Writer::Reader value); - inline ::tiledb::sm::serialization::capnp::Writer::Builder initWriter(); - inline void adoptWriter(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Writer>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Writer> disownWriter(); + inline ::tiledb::sm::serialization::capnp::Writer::Builder getWriter(); + inline void setWriter( + ::tiledb::sm::serialization::capnp::Writer::Reader value); + inline ::tiledb::sm::serialization::capnp::Writer::Builder initWriter(); + inline void adoptWriter( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Writer>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Writer> + disownWriter(); inline bool hasReader(); - inline ::tiledb::sm::serialization::capnp::QueryReader::Builder getReader(); - inline void setReader( ::tiledb::sm::serialization::capnp::QueryReader::Reader value); - inline ::tiledb::sm::serialization::capnp::QueryReader::Builder initReader(); - inline void adoptReader(::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader> disownReader(); + inline ::tiledb::sm::serialization::capnp::QueryReader::Builder getReader(); + inline void setReader( + ::tiledb::sm::serialization::capnp::QueryReader::Reader value); + inline ::tiledb::sm::serialization::capnp::QueryReader::Builder initReader(); + inline void adoptReader( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader> + disownReader(); inline bool hasArray(); - inline ::tiledb::sm::serialization::capnp::Array::Builder getArray(); - inline void setArray( ::tiledb::sm::serialization::capnp::Array::Reader value); - inline ::tiledb::sm::serialization::capnp::Array::Builder initArray(); - inline void adoptArray(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Array>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Array> disownArray(); + inline ::tiledb::sm::serialization::capnp::Array::Builder getArray(); + inline void setArray(::tiledb::sm::serialization::capnp::Array::Reader value); + inline ::tiledb::sm::serialization::capnp::Array::Builder initArray(); + inline void adoptArray( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Array>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Array> + disownArray(); - inline ::uint64_t getTotalFixedLengthBufferBytes(); - inline void setTotalFixedLengthBufferBytes( ::uint64_t value); + inline ::uint64_t getTotalFixedLengthBufferBytes(); + inline void setTotalFixedLengthBufferBytes(::uint64_t value); - inline ::uint64_t getTotalVarLenBufferBytes(); - inline void setTotalVarLenBufferBytes( ::uint64_t value); + inline ::uint64_t getTotalVarLenBufferBytes(); + inline void setTotalVarLenBufferBytes(::uint64_t value); - inline ::uint64_t getTotalValidityBufferBytes(); - inline void setTotalValidityBufferBytes( ::uint64_t value); + inline ::uint64_t getTotalValidityBufferBytes(); + inline void setTotalValidityBufferBytes(::uint64_t value); inline bool hasVarOffsetsMode(); - inline ::capnp::Text::Builder getVarOffsetsMode(); - inline void setVarOffsetsMode( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initVarOffsetsMode(unsigned int size); - inline void adoptVarOffsetsMode(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownVarOffsetsMode(); + inline ::capnp::Text::Builder getVarOffsetsMode(); + inline void setVarOffsetsMode(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initVarOffsetsMode(unsigned int size); + inline void adoptVarOffsetsMode(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownVarOffsetsMode(); inline bool getVarOffsetsAddExtraElement(); inline void setVarOffsetsAddExtraElement(bool value); - inline ::int32_t getVarOffsetsBitsize(); - inline void setVarOffsetsBitsize( ::int32_t value); + inline ::int32_t getVarOffsetsBitsize(); + inline void setVarOffsetsBitsize(::int32_t value); inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> + disownConfig(); inline bool hasStats(); - inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); - inline void setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value); - inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); - inline void adoptStats(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> disownStats(); + inline ::tiledb::sm::serialization::capnp::Stats::Builder getStats(); + inline void setStats(::tiledb::sm::serialization::capnp::Stats::Reader value); + inline ::tiledb::sm::serialization::capnp::Stats::Builder initStats(); + inline void adoptStats( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> + disownStats(); inline bool hasReaderIndex(); - inline ::tiledb::sm::serialization::capnp::ReaderIndex::Builder getReaderIndex(); - inline void setReaderIndex( ::tiledb::sm::serialization::capnp::ReaderIndex::Reader value); - inline ::tiledb::sm::serialization::capnp::ReaderIndex::Builder initReaderIndex(); - inline void adoptReaderIndex(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReaderIndex>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReaderIndex> disownReaderIndex(); + inline ::tiledb::sm::serialization::capnp::ReaderIndex::Builder + getReaderIndex(); + inline void setReaderIndex( + ::tiledb::sm::serialization::capnp::ReaderIndex::Reader value); + inline ::tiledb::sm::serialization::capnp::ReaderIndex::Builder + initReaderIndex(); + inline void adoptReaderIndex( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReaderIndex>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReaderIndex> + disownReaderIndex(); inline bool hasDenseReader(); - inline ::tiledb::sm::serialization::capnp::QueryReader::Builder getDenseReader(); - inline void setDenseReader( ::tiledb::sm::serialization::capnp::QueryReader::Reader value); - inline ::tiledb::sm::serialization::capnp::QueryReader::Builder initDenseReader(); - inline void adoptDenseReader(::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader> disownDenseReader(); + inline ::tiledb::sm::serialization::capnp::QueryReader::Builder + getDenseReader(); + inline void setDenseReader( + ::tiledb::sm::serialization::capnp::QueryReader::Reader value); + inline ::tiledb::sm::serialization::capnp::QueryReader::Builder + initDenseReader(); + inline void adoptDenseReader( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader> + disownDenseReader(); inline bool hasDelete(); - inline ::tiledb::sm::serialization::capnp::Delete::Builder getDelete(); - inline void setDelete( ::tiledb::sm::serialization::capnp::Delete::Reader value); - inline ::tiledb::sm::serialization::capnp::Delete::Builder initDelete(); - inline void adoptDelete(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Delete>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Delete> disownDelete(); + inline ::tiledb::sm::serialization::capnp::Delete::Builder getDelete(); + inline void setDelete( + ::tiledb::sm::serialization::capnp::Delete::Reader value); + inline ::tiledb::sm::serialization::capnp::Delete::Builder initDelete(); + inline void adoptDelete( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Delete>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Delete> + disownDelete(); inline bool hasWrittenFragmentInfo(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>::Builder getWrittenFragmentInfo(); - inline void setWrittenFragmentInfo( ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>::Builder initWrittenFragmentInfo(unsigned int size); - inline void adoptWrittenFragmentInfo(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>> disownWrittenFragmentInfo(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>::Builder + getWrittenFragmentInfo(); + inline void setWrittenFragmentInfo( + ::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>::Builder + initWrittenFragmentInfo(unsigned int size); + inline void adoptWrittenFragmentInfo( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>> + disownWrittenFragmentInfo(); inline bool hasWrittenBuffers(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getWrittenBuffers(); - inline void setWrittenBuffers( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setWrittenBuffers(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initWrittenBuffers(unsigned int size); - inline void adoptWrittenBuffers(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownWrittenBuffers(); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getWrittenBuffers(); + inline void setWrittenBuffers( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setWrittenBuffers( + ::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initWrittenBuffers(unsigned int size); + inline void adoptWrittenBuffers( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownWrittenBuffers(); inline bool hasOrderedDimLabelReader(); - inline ::tiledb::sm::serialization::capnp::QueryReader::Builder getOrderedDimLabelReader(); - inline void setOrderedDimLabelReader( ::tiledb::sm::serialization::capnp::QueryReader::Reader value); - inline ::tiledb::sm::serialization::capnp::QueryReader::Builder initOrderedDimLabelReader(); - inline void adoptOrderedDimLabelReader(::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader> disownOrderedDimLabelReader(); + inline ::tiledb::sm::serialization::capnp::QueryReader::Builder + getOrderedDimLabelReader(); + inline void setOrderedDimLabelReader( + ::tiledb::sm::serialization::capnp::QueryReader::Reader value); + inline ::tiledb::sm::serialization::capnp::QueryReader::Builder + initOrderedDimLabelReader(); + inline void adoptOrderedDimLabelReader( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader> + disownOrderedDimLabelReader(); inline bool hasChannels(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>::Builder getChannels(); - inline void setChannels( ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>::Builder initChannels(unsigned int size); - inline void adoptChannels(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>> disownChannels(); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>::Builder + getChannels(); + inline void setChannels(::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>::Builder + initChannels(unsigned int size); + inline void adoptChannels( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>> + disownChannels(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -7727,23 +9810,30 @@ class Query::Builder { #if !CAPNP_LITE class Query::Pipeline { -public: + public: typedef Query Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - - inline ::tiledb::sm::serialization::capnp::Writer::Pipeline getWriter(); - inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline getReader(); - inline ::tiledb::sm::serialization::capnp::Array::Pipeline getArray(); - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); - inline ::tiledb::sm::serialization::capnp::ReaderIndex::Pipeline getReaderIndex(); - inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline getDenseReader(); - inline ::tiledb::sm::serialization::capnp::Delete::Pipeline getDelete(); - inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline getOrderedDimLabelReader(); -private: + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::Writer::Pipeline getWriter(); + inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline getReader(); + inline ::tiledb::sm::serialization::capnp::Array::Pipeline getArray(); + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); + inline ::tiledb::sm::serialization::capnp::ReaderIndex::Pipeline + getReaderIndex(); + inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline + getDenseReader(); + inline ::tiledb::sm::serialization::capnp::Delete::Pipeline getDelete(); + inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline + getOrderedDimLabelReader(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -7752,11 +9842,13 @@ class Query::Pipeline { #endif // !CAPNP_LITE class NonEmptyDomain::Reader { -public: + public: typedef NonEmptyDomain Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -7769,14 +9861,16 @@ class NonEmptyDomain::Reader { #endif // !CAPNP_LITE inline bool hasNonEmptyDomain() const; - inline ::tiledb::sm::serialization::capnp::DomainArray::Reader getNonEmptyDomain() const; + inline ::tiledb::sm::serialization::capnp::DomainArray::Reader + getNonEmptyDomain() const; inline bool getIsEmpty() const; inline bool hasSizes() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getSizes() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getSizes() + const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -7789,40 +9883,62 @@ class NonEmptyDomain::Reader { }; class NonEmptyDomain::Builder { -public: + public: typedef NonEmptyDomain Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasNonEmptyDomain(); - inline ::tiledb::sm::serialization::capnp::DomainArray::Builder getNonEmptyDomain(); - inline void setNonEmptyDomain( ::tiledb::sm::serialization::capnp::DomainArray::Reader value); - inline ::tiledb::sm::serialization::capnp::DomainArray::Builder initNonEmptyDomain(); - inline void adoptNonEmptyDomain(::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray> disownNonEmptyDomain(); + inline ::tiledb::sm::serialization::capnp::DomainArray::Builder + getNonEmptyDomain(); + inline void setNonEmptyDomain( + ::tiledb::sm::serialization::capnp::DomainArray::Reader value); + inline ::tiledb::sm::serialization::capnp::DomainArray::Builder + initNonEmptyDomain(); + inline void adoptNonEmptyDomain( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray> + disownNonEmptyDomain(); inline bool getIsEmpty(); inline void setIsEmpty(bool value); inline bool hasSizes(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getSizes(); - inline void setSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setSizes(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initSizes(unsigned int size); - inline void adoptSizes(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownSizes(); - -private: + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getSizes(); + inline void setSizes( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setSizes(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initSizes( + unsigned int size); + inline void adoptSizes( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownSizes(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -7833,15 +9949,20 @@ class NonEmptyDomain::Builder { #if !CAPNP_LITE class NonEmptyDomain::Pipeline { -public: + public: typedef NonEmptyDomain Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline getNonEmptyDomain(); -private: + inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline + getNonEmptyDomain(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -7850,11 +9971,13 @@ class NonEmptyDomain::Pipeline { #endif // !CAPNP_LITE class NonEmptyDomainList::Reader { -public: + public: typedef NonEmptyDomainList Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -7867,9 +9990,12 @@ class NonEmptyDomainList::Reader { #endif // !CAPNP_LITE inline bool hasNonEmptyDomains() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>::Reader getNonEmptyDomains() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>::Reader + getNonEmptyDomains() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -7882,29 +10008,55 @@ class NonEmptyDomainList::Reader { }; class NonEmptyDomainList::Builder { -public: + public: typedef NonEmptyDomainList Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasNonEmptyDomains(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>::Builder getNonEmptyDomains(); - inline void setNonEmptyDomains( ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>::Builder initNonEmptyDomains(unsigned int size); - inline void adoptNonEmptyDomains(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>> disownNonEmptyDomains(); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>::Builder + getNonEmptyDomains(); + inline void setNonEmptyDomains( + ::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>::Builder + initNonEmptyDomains(unsigned int size); + inline void adoptNonEmptyDomains( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>> + disownNonEmptyDomains(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -7915,14 +10067,17 @@ class NonEmptyDomainList::Builder { #if !CAPNP_LITE class NonEmptyDomainList::Pipeline { -public: + public: typedef NonEmptyDomainList Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -7931,11 +10086,13 @@ class NonEmptyDomainList::Pipeline { #endif // !CAPNP_LITE class AttributeBufferSize::Reader { -public: + public: typedef AttributeBufferSize Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -7948,15 +10105,15 @@ class AttributeBufferSize::Reader { #endif // !CAPNP_LITE inline bool hasAttribute() const; - inline ::capnp::Text::Reader getAttribute() const; + inline ::capnp::Text::Reader getAttribute() const; - inline ::uint64_t getOffsetBytes() const; + inline ::uint64_t getOffsetBytes() const; - inline ::uint64_t getDataBytes() const; + inline ::uint64_t getDataBytes() const; - inline ::uint64_t getValidityBytes() const; + inline ::uint64_t getValidityBytes() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -7969,38 +10126,49 @@ class AttributeBufferSize::Reader { }; class AttributeBufferSize::Builder { -public: + public: typedef AttributeBufferSize Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasAttribute(); - inline ::capnp::Text::Builder getAttribute(); - inline void setAttribute( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initAttribute(unsigned int size); - inline void adoptAttribute(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownAttribute(); + inline ::capnp::Text::Builder getAttribute(); + inline void setAttribute(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initAttribute(unsigned int size); + inline void adoptAttribute(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownAttribute(); - inline ::uint64_t getOffsetBytes(); - inline void setOffsetBytes( ::uint64_t value); + inline ::uint64_t getOffsetBytes(); + inline void setOffsetBytes(::uint64_t value); - inline ::uint64_t getDataBytes(); - inline void setDataBytes( ::uint64_t value); + inline ::uint64_t getDataBytes(); + inline void setDataBytes(::uint64_t value); - inline ::uint64_t getValidityBytes(); - inline void setValidityBytes( ::uint64_t value); + inline ::uint64_t getValidityBytes(); + inline void setValidityBytes(::uint64_t value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8011,14 +10179,17 @@ class AttributeBufferSize::Builder { #if !CAPNP_LITE class AttributeBufferSize::Pipeline { -public: + public: typedef AttributeBufferSize Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -8027,11 +10198,13 @@ class AttributeBufferSize::Pipeline { #endif // !CAPNP_LITE class ArrayMetadata::Reader { -public: + public: typedef ArrayMetadata Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -8044,9 +10217,12 @@ class ArrayMetadata::Reader { #endif // !CAPNP_LITE inline bool hasEntries() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>::Reader getEntries() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>::Reader + getEntries() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -8059,29 +10235,55 @@ class ArrayMetadata::Reader { }; class ArrayMetadata::Builder { -public: + public: typedef ArrayMetadata Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasEntries(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>::Builder getEntries(); - inline void setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>::Builder initEntries(unsigned int size); - inline void adoptEntries(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>> disownEntries(); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>::Builder + getEntries(); + inline void setEntries( + ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>::Builder + initEntries(unsigned int size); + inline void adoptEntries( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>> + disownEntries(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8092,14 +10294,17 @@ class ArrayMetadata::Builder { #if !CAPNP_LITE class ArrayMetadata::Pipeline { -public: + public: typedef ArrayMetadata Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -8108,11 +10313,13 @@ class ArrayMetadata::Pipeline { #endif // !CAPNP_LITE class ArrayMetadata::MetadataEntry::Reader { -public: + public: typedef MetadataEntry Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -8125,19 +10332,19 @@ class ArrayMetadata::MetadataEntry::Reader { #endif // !CAPNP_LITE inline bool hasKey() const; - inline ::capnp::Text::Reader getKey() const; + inline ::capnp::Text::Reader getKey() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; - inline ::uint32_t getValueNum() const; + inline ::uint32_t getValueNum() const; inline bool hasValue() const; - inline ::capnp::Data::Reader getValue() const; + inline ::capnp::Data::Reader getValue() const; inline bool getDel() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -8150,49 +10357,60 @@ class ArrayMetadata::MetadataEntry::Reader { }; class ArrayMetadata::MetadataEntry::Builder { -public: + public: typedef MetadataEntry Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasKey(); - inline ::capnp::Text::Builder getKey(); - inline void setKey( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initKey(unsigned int size); - inline void adoptKey(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownKey(); + inline ::capnp::Text::Builder getKey(); + inline void setKey(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initKey(unsigned int size); + inline void adoptKey(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownKey(); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownType(); - inline ::uint32_t getValueNum(); - inline void setValueNum( ::uint32_t value); + inline ::uint32_t getValueNum(); + inline void setValueNum(::uint32_t value); inline bool hasValue(); - inline ::capnp::Data::Builder getValue(); - inline void setValue( ::capnp::Data::Reader value); - inline ::capnp::Data::Builder initValue(unsigned int size); - inline void adoptValue(::capnp::Orphan< ::capnp::Data>&& value); - inline ::capnp::Orphan< ::capnp::Data> disownValue(); + inline ::capnp::Data::Builder getValue(); + inline void setValue(::capnp::Data::Reader value); + inline ::capnp::Data::Builder initValue(unsigned int size); + inline void adoptValue(::capnp::Orphan<::capnp::Data>&& value); + inline ::capnp::Orphan<::capnp::Data> disownValue(); inline bool getDel(); inline void setDel(bool value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8203,14 +10421,17 @@ class ArrayMetadata::MetadataEntry::Builder { #if !CAPNP_LITE class ArrayMetadata::MetadataEntry::Pipeline { -public: + public: typedef MetadataEntry Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -8219,11 +10440,13 @@ class ArrayMetadata::MetadataEntry::Pipeline { #endif // !CAPNP_LITE class ArrayDirectory::Reader { -public: + public: typedef ArrayDirectory Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -8236,46 +10459,62 @@ class ArrayDirectory::Reader { #endif // !CAPNP_LITE inline bool hasUnfilteredFragmentUris() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getUnfilteredFragmentUris() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getUnfilteredFragmentUris() const; inline bool hasConsolidatedCommitUris() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getConsolidatedCommitUris() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getConsolidatedCommitUris() const; inline bool hasArraySchemaUris() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getArraySchemaUris() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getArraySchemaUris() const; inline bool hasLatestArraySchemaUri() const; - inline ::capnp::Text::Reader getLatestArraySchemaUri() const; + inline ::capnp::Text::Reader getLatestArraySchemaUri() const; inline bool hasArrayMetaUrisToVacuum() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getArrayMetaUrisToVacuum() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getArrayMetaUrisToVacuum() const; inline bool hasArrayMetaVacUrisToVacuum() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getArrayMetaVacUrisToVacuum() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getArrayMetaVacUrisToVacuum() const; inline bool hasCommitUrisToConsolidate() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getCommitUrisToConsolidate() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getCommitUrisToConsolidate() const; inline bool hasCommitUrisToVacuum() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getCommitUrisToVacuum() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getCommitUrisToVacuum() const; inline bool hasConsolidatedCommitUrisToVacuum() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getConsolidatedCommitUrisToVacuum() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getConsolidatedCommitUrisToVacuum() const; inline bool hasArrayMetaUris() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>::Reader getArrayMetaUris() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>::Reader + getArrayMetaUris() const; inline bool hasFragmentMetaUris() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getFragmentMetaUris() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getFragmentMetaUris() const; inline bool hasDeleteAndUpdateTileLocation() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>::Reader getDeleteAndUpdateTileLocation() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>::Reader + getDeleteAndUpdateTileLocation() const; - inline ::uint64_t getTimestampStart() const; + inline ::uint64_t getTimestampStart() const; - inline ::uint64_t getTimestampEnd() const; + inline ::uint64_t getTimestampEnd() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -8288,121 +10527,230 @@ class ArrayDirectory::Reader { }; class ArrayDirectory::Builder { -public: + public: typedef ArrayDirectory Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasUnfilteredFragmentUris(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getUnfilteredFragmentUris(); - inline void setUnfilteredFragmentUris( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setUnfilteredFragmentUris(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initUnfilteredFragmentUris(unsigned int size); - inline void adoptUnfilteredFragmentUris(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownUnfilteredFragmentUris(); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getUnfilteredFragmentUris(); + inline void setUnfilteredFragmentUris( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setUnfilteredFragmentUris( + ::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initUnfilteredFragmentUris(unsigned int size); + inline void adoptUnfilteredFragmentUris( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownUnfilteredFragmentUris(); inline bool hasConsolidatedCommitUris(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getConsolidatedCommitUris(); - inline void setConsolidatedCommitUris( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setConsolidatedCommitUris(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initConsolidatedCommitUris(unsigned int size); - inline void adoptConsolidatedCommitUris(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownConsolidatedCommitUris(); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getConsolidatedCommitUris(); + inline void setConsolidatedCommitUris( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setConsolidatedCommitUris( + ::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initConsolidatedCommitUris(unsigned int size); + inline void adoptConsolidatedCommitUris( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownConsolidatedCommitUris(); inline bool hasArraySchemaUris(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getArraySchemaUris(); - inline void setArraySchemaUris( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setArraySchemaUris(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initArraySchemaUris(unsigned int size); - inline void adoptArraySchemaUris(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownArraySchemaUris(); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getArraySchemaUris(); + inline void setArraySchemaUris( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setArraySchemaUris( + ::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initArraySchemaUris(unsigned int size); + inline void adoptArraySchemaUris( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownArraySchemaUris(); inline bool hasLatestArraySchemaUri(); - inline ::capnp::Text::Builder getLatestArraySchemaUri(); - inline void setLatestArraySchemaUri( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initLatestArraySchemaUri(unsigned int size); - inline void adoptLatestArraySchemaUri(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownLatestArraySchemaUri(); + inline ::capnp::Text::Builder getLatestArraySchemaUri(); + inline void setLatestArraySchemaUri(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initLatestArraySchemaUri(unsigned int size); + inline void adoptLatestArraySchemaUri(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownLatestArraySchemaUri(); inline bool hasArrayMetaUrisToVacuum(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getArrayMetaUrisToVacuum(); - inline void setArrayMetaUrisToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setArrayMetaUrisToVacuum(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initArrayMetaUrisToVacuum(unsigned int size); - inline void adoptArrayMetaUrisToVacuum(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownArrayMetaUrisToVacuum(); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getArrayMetaUrisToVacuum(); + inline void setArrayMetaUrisToVacuum( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setArrayMetaUrisToVacuum( + ::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initArrayMetaUrisToVacuum(unsigned int size); + inline void adoptArrayMetaUrisToVacuum( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownArrayMetaUrisToVacuum(); inline bool hasArrayMetaVacUrisToVacuum(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getArrayMetaVacUrisToVacuum(); - inline void setArrayMetaVacUrisToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setArrayMetaVacUrisToVacuum(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initArrayMetaVacUrisToVacuum(unsigned int size); - inline void adoptArrayMetaVacUrisToVacuum(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownArrayMetaVacUrisToVacuum(); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getArrayMetaVacUrisToVacuum(); + inline void setArrayMetaVacUrisToVacuum( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setArrayMetaVacUrisToVacuum( + ::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initArrayMetaVacUrisToVacuum(unsigned int size); + inline void adoptArrayMetaVacUrisToVacuum( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownArrayMetaVacUrisToVacuum(); inline bool hasCommitUrisToConsolidate(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getCommitUrisToConsolidate(); - inline void setCommitUrisToConsolidate( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setCommitUrisToConsolidate(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initCommitUrisToConsolidate(unsigned int size); - inline void adoptCommitUrisToConsolidate(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownCommitUrisToConsolidate(); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getCommitUrisToConsolidate(); + inline void setCommitUrisToConsolidate( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setCommitUrisToConsolidate( + ::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initCommitUrisToConsolidate(unsigned int size); + inline void adoptCommitUrisToConsolidate( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownCommitUrisToConsolidate(); inline bool hasCommitUrisToVacuum(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getCommitUrisToVacuum(); - inline void setCommitUrisToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setCommitUrisToVacuum(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initCommitUrisToVacuum(unsigned int size); - inline void adoptCommitUrisToVacuum(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownCommitUrisToVacuum(); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getCommitUrisToVacuum(); + inline void setCommitUrisToVacuum( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setCommitUrisToVacuum( + ::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initCommitUrisToVacuum(unsigned int size); + inline void adoptCommitUrisToVacuum( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownCommitUrisToVacuum(); inline bool hasConsolidatedCommitUrisToVacuum(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getConsolidatedCommitUrisToVacuum(); - inline void setConsolidatedCommitUrisToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setConsolidatedCommitUrisToVacuum(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initConsolidatedCommitUrisToVacuum(unsigned int size); - inline void adoptConsolidatedCommitUrisToVacuum(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownConsolidatedCommitUrisToVacuum(); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getConsolidatedCommitUrisToVacuum(); + inline void setConsolidatedCommitUrisToVacuum( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setConsolidatedCommitUrisToVacuum( + ::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initConsolidatedCommitUrisToVacuum(unsigned int size); + inline void adoptConsolidatedCommitUrisToVacuum( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownConsolidatedCommitUrisToVacuum(); inline bool hasArrayMetaUris(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>::Builder getArrayMetaUris(); - inline void setArrayMetaUris( ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>::Builder initArrayMetaUris(unsigned int size); - inline void adoptArrayMetaUris(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>> disownArrayMetaUris(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>::Builder + getArrayMetaUris(); + inline void setArrayMetaUris( + ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>::Builder + initArrayMetaUris(unsigned int size); + inline void adoptArrayMetaUris( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>> + disownArrayMetaUris(); inline bool hasFragmentMetaUris(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getFragmentMetaUris(); - inline void setFragmentMetaUris( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setFragmentMetaUris(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initFragmentMetaUris(unsigned int size); - inline void adoptFragmentMetaUris(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownFragmentMetaUris(); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getFragmentMetaUris(); + inline void setFragmentMetaUris( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setFragmentMetaUris( + ::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initFragmentMetaUris(unsigned int size); + inline void adoptFragmentMetaUris( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownFragmentMetaUris(); inline bool hasDeleteAndUpdateTileLocation(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>::Builder getDeleteAndUpdateTileLocation(); - inline void setDeleteAndUpdateTileLocation( ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>::Builder initDeleteAndUpdateTileLocation(unsigned int size); - inline void adoptDeleteAndUpdateTileLocation(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>> disownDeleteAndUpdateTileLocation(); - - inline ::uint64_t getTimestampStart(); - inline void setTimestampStart( ::uint64_t value); - - inline ::uint64_t getTimestampEnd(); - inline void setTimestampEnd( ::uint64_t value); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>::Builder + getDeleteAndUpdateTileLocation(); + inline void setDeleteAndUpdateTileLocation( + ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>::Builder + initDeleteAndUpdateTileLocation(unsigned int size); + inline void adoptDeleteAndUpdateTileLocation( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>> + disownDeleteAndUpdateTileLocation(); + + inline ::uint64_t getTimestampStart(); + inline void setTimestampStart(::uint64_t value); + + inline ::uint64_t getTimestampEnd(); + inline void setTimestampEnd(::uint64_t value); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8413,14 +10761,17 @@ class ArrayDirectory::Builder { #if !CAPNP_LITE class ArrayDirectory::Pipeline { -public: + public: typedef ArrayDirectory Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -8429,11 +10780,13 @@ class ArrayDirectory::Pipeline { #endif // !CAPNP_LITE class ArrayDirectory::TimestampedURI::Reader { -public: + public: typedef TimestampedURI Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -8446,13 +10799,13 @@ class ArrayDirectory::TimestampedURI::Reader { #endif // !CAPNP_LITE inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; - inline ::uint64_t getTimestampStart() const; + inline ::uint64_t getTimestampStart() const; - inline ::uint64_t getTimestampEnd() const; + inline ::uint64_t getTimestampEnd() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -8465,35 +10818,46 @@ class ArrayDirectory::TimestampedURI::Reader { }; class ArrayDirectory::TimestampedURI::Builder { -public: + public: typedef TimestampedURI Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownUri(); - inline ::uint64_t getTimestampStart(); - inline void setTimestampStart( ::uint64_t value); + inline ::uint64_t getTimestampStart(); + inline void setTimestampStart(::uint64_t value); - inline ::uint64_t getTimestampEnd(); - inline void setTimestampEnd( ::uint64_t value); + inline ::uint64_t getTimestampEnd(); + inline void setTimestampEnd(::uint64_t value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8504,14 +10868,17 @@ class ArrayDirectory::TimestampedURI::Builder { #if !CAPNP_LITE class ArrayDirectory::TimestampedURI::Pipeline { -public: + public: typedef TimestampedURI Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -8520,11 +10887,13 @@ class ArrayDirectory::TimestampedURI::Pipeline { #endif // !CAPNP_LITE class ArrayDirectory::DeleteAndUpdateTileLocation::Reader { -public: + public: typedef DeleteAndUpdateTileLocation Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -8537,14 +10906,14 @@ class ArrayDirectory::DeleteAndUpdateTileLocation::Reader { #endif // !CAPNP_LITE inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; inline bool hasConditionMarker() const; - inline ::capnp::Text::Reader getConditionMarker() const; + inline ::capnp::Text::Reader getConditionMarker() const; - inline ::uint64_t getOffset() const; + inline ::uint64_t getOffset() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -8557,39 +10926,50 @@ class ArrayDirectory::DeleteAndUpdateTileLocation::Reader { }; class ArrayDirectory::DeleteAndUpdateTileLocation::Builder { -public: + public: typedef DeleteAndUpdateTileLocation Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownUri(); inline bool hasConditionMarker(); - inline ::capnp::Text::Builder getConditionMarker(); - inline void setConditionMarker( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initConditionMarker(unsigned int size); - inline void adoptConditionMarker(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownConditionMarker(); + inline ::capnp::Text::Builder getConditionMarker(); + inline void setConditionMarker(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initConditionMarker(unsigned int size); + inline void adoptConditionMarker(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownConditionMarker(); - inline ::uint64_t getOffset(); - inline void setOffset( ::uint64_t value); + inline ::uint64_t getOffset(); + inline void setOffset(::uint64_t value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8600,14 +10980,17 @@ class ArrayDirectory::DeleteAndUpdateTileLocation::Builder { #if !CAPNP_LITE class ArrayDirectory::DeleteAndUpdateTileLocation::Pipeline { -public: + public: typedef DeleteAndUpdateTileLocation Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -8616,11 +10999,13 @@ class ArrayDirectory::DeleteAndUpdateTileLocation::Pipeline { #endif // !CAPNP_LITE class EstimatedResultSize::Reader { -public: + public: typedef EstimatedResultSize Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -8633,12 +11018,20 @@ class EstimatedResultSize::Reader { #endif // !CAPNP_LITE inline bool hasResultSizes() const; - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Reader getResultSizes() const; + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: + Reader + getResultSizes() const; inline bool hasMemorySizes() const; - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Reader getMemorySizes() const; + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: + Reader + getMemorySizes() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -8651,36 +11044,85 @@ class EstimatedResultSize::Reader { }; class EstimatedResultSize::Builder { -public: + public: typedef EstimatedResultSize Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasResultSizes(); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Builder getResultSizes(); - inline void setResultSizes( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Reader value); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Builder initResultSizes(); - inline void adoptResultSizes(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>> disownResultSizes(); + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: + Builder + getResultSizes(); + inline void setResultSizes( + ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: + Reader value); + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: + Builder + initResultSizes(); + inline void adoptResultSizes( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize:: + ResultSize>>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>> + disownResultSizes(); inline bool hasMemorySizes(); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Builder getMemorySizes(); - inline void setMemorySizes( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Reader value); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Builder initMemorySizes(); - inline void adoptMemorySizes(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>> disownMemorySizes(); - -private: + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: + Builder + getMemorySizes(); + inline void setMemorySizes( + ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: + Reader value); + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: + Builder + initMemorySizes(); + inline void adoptMemorySizes( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize:: + MemorySize>>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>> + disownMemorySizes(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8691,16 +11133,28 @@ class EstimatedResultSize::Builder { #if !CAPNP_LITE class EstimatedResultSize::Pipeline { -public: + public: typedef EstimatedResultSize Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Pipeline getResultSizes(); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Pipeline getMemorySizes(); -private: + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: + Pipeline + getResultSizes(); + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: + Pipeline + getMemorySizes(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -8709,11 +11163,13 @@ class EstimatedResultSize::Pipeline { #endif // !CAPNP_LITE class EstimatedResultSize::ResultSize::Reader { -public: + public: typedef ResultSize Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -8731,7 +11187,7 @@ class EstimatedResultSize::ResultSize::Reader { inline double getSizeValidity() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -8744,19 +11200,30 @@ class EstimatedResultSize::ResultSize::Reader { }; class EstimatedResultSize::ResultSize::Builder { -public: + public: typedef ResultSize Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline double getSizeFixed(); @@ -8768,7 +11235,7 @@ class EstimatedResultSize::ResultSize::Builder { inline double getSizeValidity(); inline void setSizeValidity(double value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8779,14 +11246,17 @@ class EstimatedResultSize::ResultSize::Builder { #if !CAPNP_LITE class EstimatedResultSize::ResultSize::Pipeline { -public: + public: typedef ResultSize Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -8795,11 +11265,13 @@ class EstimatedResultSize::ResultSize::Pipeline { #endif // !CAPNP_LITE class EstimatedResultSize::MemorySize::Reader { -public: + public: typedef MemorySize Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -8811,13 +11283,13 @@ class EstimatedResultSize::MemorySize::Reader { } #endif // !CAPNP_LITE - inline ::uint64_t getSizeFixed() const; + inline ::uint64_t getSizeFixed() const; - inline ::uint64_t getSizeVar() const; + inline ::uint64_t getSizeVar() const; - inline ::uint64_t getSizeValidity() const; + inline ::uint64_t getSizeValidity() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -8830,31 +11302,42 @@ class EstimatedResultSize::MemorySize::Reader { }; class EstimatedResultSize::MemorySize::Builder { -public: + public: typedef MemorySize Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE - inline ::uint64_t getSizeFixed(); - inline void setSizeFixed( ::uint64_t value); + inline ::uint64_t getSizeFixed(); + inline void setSizeFixed(::uint64_t value); - inline ::uint64_t getSizeVar(); - inline void setSizeVar( ::uint64_t value); + inline ::uint64_t getSizeVar(); + inline void setSizeVar(::uint64_t value); - inline ::uint64_t getSizeValidity(); - inline void setSizeValidity( ::uint64_t value); + inline ::uint64_t getSizeValidity(); + inline void setSizeValidity(::uint64_t value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8865,14 +11348,17 @@ class EstimatedResultSize::MemorySize::Builder { #if !CAPNP_LITE class EstimatedResultSize::MemorySize::Pipeline { -public: + public: typedef MemorySize Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -8881,11 +11367,13 @@ class EstimatedResultSize::MemorySize::Pipeline { #endif // !CAPNP_LITE class FragmentInfoRequest::Reader { -public: + public: typedef FragmentInfoRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -8898,9 +11386,9 @@ class FragmentInfoRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -8913,29 +11401,43 @@ class FragmentInfoRequest::Reader { }; class FragmentInfoRequest::Builder { -public: + public: typedef FragmentInfoRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); - -private: + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> + disownConfig(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -8946,15 +11448,19 @@ class FragmentInfoRequest::Builder { #if !CAPNP_LITE class FragmentInfoRequest::Pipeline { -public: + public: typedef FragmentInfoRequest Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -8963,11 +11469,13 @@ class FragmentInfoRequest::Pipeline { #endif // !CAPNP_LITE class SingleFragmentInfo::Reader { -public: + public: typedef SingleFragmentInfo Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -8980,14 +11488,15 @@ class SingleFragmentInfo::Reader { #endif // !CAPNP_LITE inline bool hasArraySchemaName() const; - inline ::capnp::Text::Reader getArraySchemaName() const; + inline ::capnp::Text::Reader getArraySchemaName() const; inline bool hasMeta() const; - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader getMeta() const; + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader getMeta() + const; - inline ::uint64_t getFragmentSize() const; + inline ::uint64_t getFragmentSize() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -9000,39 +11509,56 @@ class SingleFragmentInfo::Reader { }; class SingleFragmentInfo::Builder { -public: + public: typedef SingleFragmentInfo Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasArraySchemaName(); - inline ::capnp::Text::Builder getArraySchemaName(); - inline void setArraySchemaName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initArraySchemaName(unsigned int size); - inline void adoptArraySchemaName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownArraySchemaName(); + inline ::capnp::Text::Builder getArraySchemaName(); + inline void setArraySchemaName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initArraySchemaName(unsigned int size); + inline void adoptArraySchemaName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownArraySchemaName(); inline bool hasMeta(); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder getMeta(); - inline void setMeta( ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder initMeta(); - inline void adoptMeta(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata> disownMeta(); - - inline ::uint64_t getFragmentSize(); - inline void setFragmentSize( ::uint64_t value); - -private: + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder + getMeta(); + inline void setMeta( + ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value); + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder + initMeta(); + inline void adoptMeta( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata> + disownMeta(); + + inline ::uint64_t getFragmentSize(); + inline void setFragmentSize(::uint64_t value); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -9043,15 +11569,20 @@ class SingleFragmentInfo::Builder { #if !CAPNP_LITE class SingleFragmentInfo::Pipeline { -public: + public: typedef SingleFragmentInfo Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline + getMeta(); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline getMeta(); -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -9060,11 +11591,13 @@ class SingleFragmentInfo::Pipeline { #endif // !CAPNP_LITE class FragmentInfo::Reader { -public: + public: typedef FragmentInfo Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -9077,18 +11610,26 @@ class FragmentInfo::Reader { #endif // !CAPNP_LITE inline bool hasArraySchemaLatest() const; - inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader getArraySchemaLatest() const; + inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader + getArraySchemaLatest() const; inline bool hasArraySchemasAll() const; - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader getArraySchemasAll() const; + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Reader + getArraySchemasAll() const; inline bool hasFragmentInfo() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>::Reader getFragmentInfo() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>::Reader + getFragmentInfo() const; inline bool hasToVacuum() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getToVacuum() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader getToVacuum() + const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -9101,51 +11642,103 @@ class FragmentInfo::Reader { }; class FragmentInfo::Builder { -public: + public: typedef FragmentInfo Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasArraySchemaLatest(); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder getArraySchemaLatest(); - inline void setArraySchemaLatest( ::tiledb::sm::serialization::capnp::ArraySchema::Reader value); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder initArraySchemaLatest(); - inline void adoptArraySchemaLatest(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema> disownArraySchemaLatest(); + inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder + getArraySchemaLatest(); + inline void setArraySchemaLatest( + ::tiledb::sm::serialization::capnp::ArraySchema::Reader value); + inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder + initArraySchemaLatest(); + inline void adoptArraySchemaLatest( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema> + disownArraySchemaLatest(); inline bool hasArraySchemasAll(); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder getArraySchemasAll(); - inline void setArraySchemasAll( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder initArraySchemasAll(); - inline void adoptArraySchemasAll(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>> disownArraySchemasAll(); + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Builder + getArraySchemasAll(); + inline void setArraySchemasAll( + ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value); + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Builder + initArraySchemasAll(); + inline void adoptArraySchemasAll( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>> + disownArraySchemasAll(); inline bool hasFragmentInfo(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>::Builder getFragmentInfo(); - inline void setFragmentInfo( ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>::Builder initFragmentInfo(unsigned int size); - inline void adoptFragmentInfo(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>> disownFragmentInfo(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>::Builder + getFragmentInfo(); + inline void setFragmentInfo( + ::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>::Builder + initFragmentInfo(unsigned int size); + inline void adoptFragmentInfo( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>> + disownFragmentInfo(); inline bool hasToVacuum(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getToVacuum(); - inline void setToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setToVacuum(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initToVacuum(unsigned int size); - inline void adoptToVacuum(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownToVacuum(); - -private: + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getToVacuum(); + inline void setToVacuum( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setToVacuum(::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initToVacuum(unsigned int size); + inline void adoptToVacuum( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownToVacuum(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -9156,16 +11749,24 @@ class FragmentInfo::Builder { #if !CAPNP_LITE class FragmentInfo::Pipeline { -public: + public: typedef FragmentInfo Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline + getArraySchemaLatest(); + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline + getArraySchemasAll(); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline getArraySchemaLatest(); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline getArraySchemasAll(); -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -9174,11 +11775,13 @@ class FragmentInfo::Pipeline { #endif // !CAPNP_LITE class GroupMetadata::Reader { -public: + public: typedef GroupMetadata Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -9191,12 +11794,13 @@ class GroupMetadata::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasMetadata() const; - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader getMetadata() const; + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader getMetadata() + const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -9209,36 +11813,56 @@ class GroupMetadata::Reader { }; class GroupMetadata::Builder { -public: + public: typedef GroupMetadata Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> + disownConfig(); inline bool hasMetadata(); - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder getMetadata(); - inline void setMetadata( ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value); - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder initMetadata(); - inline void adoptMetadata(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata> disownMetadata(); - -private: + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder + getMetadata(); + inline void setMetadata( + ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value); + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder + initMetadata(); + inline void adoptMetadata( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata> + disownMetadata(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -9249,16 +11873,21 @@ class GroupMetadata::Builder { #if !CAPNP_LITE class GroupMetadata::Pipeline { -public: + public: typedef GroupMetadata Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline getMetadata(); -private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline + getMetadata(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -9267,11 +11896,13 @@ class GroupMetadata::Pipeline { #endif // !CAPNP_LITE class GroupMember::Reader { -public: + public: typedef GroupMember Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -9284,17 +11915,17 @@ class GroupMember::Reader { #endif // !CAPNP_LITE inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; inline bool getRelative() const; inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -9307,46 +11938,57 @@ class GroupMember::Reader { }; class GroupMember::Builder { -public: + public: typedef GroupMember Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } - - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } + + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownUri(); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownType(); inline bool getRelative(); inline void setRelative(bool value); inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownName(); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -9357,14 +11999,17 @@ class GroupMember::Builder { #if !CAPNP_LITE class GroupMember::Pipeline { -public: + public: typedef GroupMember Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -9373,11 +12018,13 @@ class GroupMember::Pipeline { #endif // !CAPNP_LITE class Group::Reader { -public: + public: typedef Group Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -9390,12 +12037,13 @@ class Group::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasGroup() const; - inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Reader getGroup() const; + inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Reader + getGroup() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -9408,36 +12056,57 @@ class Group::Reader { }; class Group::Builder { -public: + public: typedef Group Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> + disownConfig(); inline bool hasGroup(); - inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Builder getGroup(); - inline void setGroup( ::tiledb::sm::serialization::capnp::Group::GroupDetails::Reader value); - inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Builder initGroup(); - inline void adoptGroup(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Group::GroupDetails>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Group::GroupDetails> disownGroup(); - -private: + inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Builder + getGroup(); + inline void setGroup( + ::tiledb::sm::serialization::capnp::Group::GroupDetails::Reader value); + inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Builder + initGroup(); + inline void adoptGroup( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Group::GroupDetails>&& + value); + inline ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::Group::GroupDetails> + disownGroup(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -9448,16 +12117,21 @@ class Group::Builder { #if !CAPNP_LITE class Group::Pipeline { -public: + public: typedef Group Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Pipeline getGroup(); -private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Pipeline + getGroup(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -9466,11 +12140,13 @@ class Group::Pipeline { #endif // !CAPNP_LITE class Group::GroupDetails::Reader { -public: + public: typedef GroupDetails Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -9483,12 +12159,16 @@ class Group::GroupDetails::Reader { #endif // !CAPNP_LITE inline bool hasMembers() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Reader getMembers() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>::Reader + getMembers() const; inline bool hasMetadata() const; - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader getMetadata() const; + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader getMetadata() + const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -9501,36 +12181,66 @@ class Group::GroupDetails::Reader { }; class Group::GroupDetails::Builder { -public: + public: typedef GroupDetails Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasMembers(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Builder getMembers(); - inline void setMembers( ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Builder initMembers(unsigned int size); - inline void adoptMembers(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>> disownMembers(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>::Builder + getMembers(); + inline void setMembers(::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>::Builder + initMembers(unsigned int size); + inline void adoptMembers(::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>> + disownMembers(); inline bool hasMetadata(); - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder getMetadata(); - inline void setMetadata( ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value); - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder initMetadata(); - inline void adoptMetadata(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata> disownMetadata(); - -private: + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder + getMetadata(); + inline void setMetadata( + ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value); + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder + initMetadata(); + inline void adoptMetadata( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata> + disownMetadata(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -9541,15 +12251,20 @@ class Group::GroupDetails::Builder { #if !CAPNP_LITE class Group::GroupDetails::Pipeline { -public: + public: typedef GroupDetails Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline + getMetadata(); - inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline getMetadata(); -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -9558,11 +12273,13 @@ class Group::GroupDetails::Pipeline { #endif // !CAPNP_LITE class GroupUpdate::Reader { -public: + public: typedef GroupUpdate Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -9575,12 +12292,14 @@ class GroupUpdate::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasGroupUpdate() const; - inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Reader getGroupUpdate() const; + inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: + Reader + getGroupUpdate() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -9593,36 +12312,60 @@ class GroupUpdate::Reader { }; class GroupUpdate::Builder { -public: + public: typedef GroupUpdate Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> + disownConfig(); inline bool hasGroupUpdate(); - inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Builder getGroupUpdate(); - inline void setGroupUpdate( ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Reader value); - inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Builder initGroupUpdate(); - inline void adoptGroupUpdate(::capnp::Orphan< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails> disownGroupUpdate(); - -private: + inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: + Builder + getGroupUpdate(); + inline void setGroupUpdate(::tiledb::sm::serialization::capnp::GroupUpdate:: + GroupUpdateDetails::Reader value); + inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: + Builder + initGroupUpdate(); + inline void adoptGroupUpdate( + ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>&& + value); + inline ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails> + disownGroupUpdate(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -9633,16 +12376,22 @@ class GroupUpdate::Builder { #if !CAPNP_LITE class GroupUpdate::Pipeline { -public: + public: typedef GroupUpdate Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Pipeline getGroupUpdate(); -private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: + Pipeline + getGroupUpdate(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -9651,11 +12400,13 @@ class GroupUpdate::Pipeline { #endif // !CAPNP_LITE class GroupUpdate::GroupUpdateDetails::Reader { -public: + public: typedef GroupUpdateDetails Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -9668,12 +12419,16 @@ class GroupUpdate::GroupUpdateDetails::Reader { #endif // !CAPNP_LITE inline bool hasMembersToRemove() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getMembersToRemove() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getMembersToRemove() const; inline bool hasMembersToAdd() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Reader getMembersToAdd() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>::Reader + getMembersToAdd() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -9686,37 +12441,69 @@ class GroupUpdate::GroupUpdateDetails::Reader { }; class GroupUpdate::GroupUpdateDetails::Builder { -public: + public: typedef GroupUpdateDetails Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasMembersToRemove(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getMembersToRemove(); - inline void setMembersToRemove( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setMembersToRemove(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initMembersToRemove(unsigned int size); - inline void adoptMembersToRemove(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownMembersToRemove(); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getMembersToRemove(); + inline void setMembersToRemove( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setMembersToRemove( + ::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initMembersToRemove(unsigned int size); + inline void adoptMembersToRemove( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownMembersToRemove(); inline bool hasMembersToAdd(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Builder getMembersToAdd(); - inline void setMembersToAdd( ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Builder initMembersToAdd(unsigned int size); - inline void adoptMembersToAdd(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>> disownMembersToAdd(); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>::Builder + getMembersToAdd(); + inline void setMembersToAdd(::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>::Builder + initMembersToAdd(unsigned int size); + inline void adoptMembersToAdd( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>> + disownMembersToAdd(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -9727,14 +12514,17 @@ class GroupUpdate::GroupUpdateDetails::Builder { #if !CAPNP_LITE class GroupUpdate::GroupUpdateDetails::Pipeline { -public: + public: typedef GroupUpdateDetails Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -9743,11 +12533,13 @@ class GroupUpdate::GroupUpdateDetails::Pipeline { #endif // !CAPNP_LITE class GroupCreate::Reader { -public: + public: typedef GroupCreate Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -9760,12 +12552,14 @@ class GroupCreate::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasGroupDetails() const; - inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Reader getGroupDetails() const; + inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: + Reader + getGroupDetails() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -9778,36 +12572,60 @@ class GroupCreate::Reader { }; class GroupCreate::Builder { -public: + public: typedef GroupCreate Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> + disownConfig(); inline bool hasGroupDetails(); - inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Builder getGroupDetails(); - inline void setGroupDetails( ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Reader value); - inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Builder initGroupDetails(); - inline void adoptGroupDetails(::capnp::Orphan< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails> disownGroupDetails(); - -private: + inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: + Builder + getGroupDetails(); + inline void setGroupDetails(::tiledb::sm::serialization::capnp::GroupCreate:: + GroupCreateDetails::Reader value); + inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: + Builder + initGroupDetails(); + inline void adoptGroupDetails( + ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>&& + value); + inline ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails> + disownGroupDetails(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -9818,16 +12636,22 @@ class GroupCreate::Builder { #if !CAPNP_LITE class GroupCreate::Pipeline { -public: + public: typedef GroupCreate Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: + Pipeline + getGroupDetails(); - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Pipeline getGroupDetails(); -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -9836,11 +12660,13 @@ class GroupCreate::Pipeline { #endif // !CAPNP_LITE class GroupCreate::GroupCreateDetails::Reader { -public: + public: typedef GroupCreateDetails Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -9853,9 +12679,9 @@ class GroupCreate::GroupCreateDetails::Reader { #endif // !CAPNP_LITE inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -9868,29 +12694,40 @@ class GroupCreate::GroupCreateDetails::Reader { }; class GroupCreate::GroupCreateDetails::Builder { -public: + public: typedef GroupCreateDetails Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownUri(); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -9901,14 +12738,17 @@ class GroupCreate::GroupCreateDetails::Builder { #if !CAPNP_LITE class GroupCreate::GroupCreateDetails::Pipeline { -public: + public: typedef GroupCreateDetails Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -9917,11 +12757,13 @@ class GroupCreate::GroupCreateDetails::Pipeline { #endif // !CAPNP_LITE class GlobalWriteState::Reader { -public: + public: typedef GlobalWriteState Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -9934,20 +12776,26 @@ class GlobalWriteState::Reader { #endif // !CAPNP_LITE inline bool hasCellsWritten() const; - inline ::tiledb::sm::serialization::capnp::MapUInt64::Reader getCellsWritten() const; + inline ::tiledb::sm::serialization::capnp::MapUInt64::Reader getCellsWritten() + const; inline bool hasFragMeta() const; - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader getFragMeta() const; + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader + getFragMeta() const; inline bool hasLastCellCoords() const; - inline ::tiledb::sm::serialization::capnp::SingleCoord::Reader getLastCellCoords() const; + inline ::tiledb::sm::serialization::capnp::SingleCoord::Reader + getLastCellCoords() const; - inline ::uint64_t getLastHilbertValue() const; + inline ::uint64_t getLastHilbertValue() const; inline bool hasMultiPartUploadStates() const; - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Reader getMultiPartUploadStates() const; + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Reader + getMultiPartUploadStates() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -9960,53 +12808,96 @@ class GlobalWriteState::Reader { }; class GlobalWriteState::Builder { -public: + public: typedef GlobalWriteState Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasCellsWritten(); - inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder getCellsWritten(); - inline void setCellsWritten( ::tiledb::sm::serialization::capnp::MapUInt64::Reader value); - inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder initCellsWritten(); - inline void adoptCellsWritten(::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapUInt64>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapUInt64> disownCellsWritten(); + inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder + getCellsWritten(); + inline void setCellsWritten( + ::tiledb::sm::serialization::capnp::MapUInt64::Reader value); + inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder + initCellsWritten(); + inline void adoptCellsWritten( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapUInt64>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapUInt64> + disownCellsWritten(); inline bool hasFragMeta(); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder getFragMeta(); - inline void setFragMeta( ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder initFragMeta(); - inline void adoptFragMeta(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata> disownFragMeta(); + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder + getFragMeta(); + inline void setFragMeta( + ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value); + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder + initFragMeta(); + inline void adoptFragMeta( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata> + disownFragMeta(); inline bool hasLastCellCoords(); - inline ::tiledb::sm::serialization::capnp::SingleCoord::Builder getLastCellCoords(); - inline void setLastCellCoords( ::tiledb::sm::serialization::capnp::SingleCoord::Reader value); - inline ::tiledb::sm::serialization::capnp::SingleCoord::Builder initLastCellCoords(); - inline void adoptLastCellCoords(::capnp::Orphan< ::tiledb::sm::serialization::capnp::SingleCoord>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SingleCoord> disownLastCellCoords(); - - inline ::uint64_t getLastHilbertValue(); - inline void setLastHilbertValue( ::uint64_t value); + inline ::tiledb::sm::serialization::capnp::SingleCoord::Builder + getLastCellCoords(); + inline void setLastCellCoords( + ::tiledb::sm::serialization::capnp::SingleCoord::Reader value); + inline ::tiledb::sm::serialization::capnp::SingleCoord::Builder + initLastCellCoords(); + inline void adoptLastCellCoords( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::SingleCoord>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::SingleCoord> + disownLastCellCoords(); + + inline ::uint64_t getLastHilbertValue(); + inline void setLastHilbertValue(::uint64_t value); inline bool hasMultiPartUploadStates(); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Builder getMultiPartUploadStates(); - inline void setMultiPartUploadStates( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Reader value); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Builder initMultiPartUploadStates(); - inline void adoptMultiPartUploadStates(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>> disownMultiPartUploadStates(); - -private: + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Builder + getMultiPartUploadStates(); + inline void setMultiPartUploadStates( + ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Reader + value); + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Builder + initMultiPartUploadStates(); + inline void adoptMultiPartUploadStates( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>> + disownMultiPartUploadStates(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -10017,18 +12908,28 @@ class GlobalWriteState::Builder { #if !CAPNP_LITE class GlobalWriteState::Pipeline { -public: + public: typedef GlobalWriteState Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline getCellsWritten(); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline getFragMeta(); - inline ::tiledb::sm::serialization::capnp::SingleCoord::Pipeline getLastCellCoords(); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Pipeline getMultiPartUploadStates(); -private: + inline ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline + getCellsWritten(); + inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline + getFragMeta(); + inline ::tiledb::sm::serialization::capnp::SingleCoord::Pipeline + getLastCellCoords(); + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Pipeline + getMultiPartUploadStates(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -10037,11 +12938,13 @@ class GlobalWriteState::Pipeline { #endif // !CAPNP_LITE class SingleCoord::Reader { -public: + public: typedef SingleCoord Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -10054,15 +12957,20 @@ class SingleCoord::Reader { #endif // !CAPNP_LITE inline bool hasCoords() const; - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getCoords() const; + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader + getCoords() const; inline bool hasSizes() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getSizes() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getSizes() + const; inline bool hasSingleOffset() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getSingleOffset() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getSingleOffset() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -10075,46 +12983,86 @@ class SingleCoord::Reader { }; class SingleCoord::Builder { -public: + public: typedef SingleCoord Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasCoords(); - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getCoords(); - inline void setCoords( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); - inline void setCoords(::kj::ArrayPtr::Reader> value); - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initCoords(unsigned int size); - inline void adoptCoords(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownCoords(); + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + getCoords(); + inline void setCoords(::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value); + inline void setCoords( + ::kj::ArrayPtr< + const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> + value); + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + initCoords(unsigned int size); + inline void adoptCoords( + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> + disownCoords(); inline bool hasSizes(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getSizes(); - inline void setSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setSizes(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initSizes(unsigned int size); - inline void adoptSizes(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownSizes(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getSizes(); + inline void setSizes( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setSizes(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initSizes( + unsigned int size); + inline void adoptSizes( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownSizes(); inline bool hasSingleOffset(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getSingleOffset(); - inline void setSingleOffset( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setSingleOffset(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initSingleOffset(unsigned int size); - inline void adoptSingleOffset(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownSingleOffset(); - -private: + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getSingleOffset(); + inline void setSingleOffset( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setSingleOffset(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initSingleOffset(unsigned int size); + inline void adoptSingleOffset( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownSingleOffset(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -10125,14 +13073,17 @@ class SingleCoord::Builder { #if !CAPNP_LITE class SingleCoord::Pipeline { -public: + public: typedef SingleCoord Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -10141,11 +13092,13 @@ class SingleCoord::Pipeline { #endif // !CAPNP_LITE class FragmentMetadata::Reader { -public: + public: typedef FragmentMetadata Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -10158,89 +13111,134 @@ class FragmentMetadata::Reader { #endif // !CAPNP_LITE inline bool hasFileSizes() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getFileSizes() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getFileSizes() const; inline bool hasFileVarSizes() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getFileVarSizes() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getFileVarSizes() const; inline bool hasFileValiditySizes() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getFileValiditySizes() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getFileValiditySizes() const; inline bool hasFragmentUri() const; - inline ::capnp::Text::Reader getFragmentUri() const; + inline ::capnp::Text::Reader getFragmentUri() const; inline bool getHasTimestamps() const; inline bool getHasDeleteMeta() const; - inline ::uint64_t getSparseTileNum() const; + inline ::uint64_t getSparseTileNum() const; - inline ::uint64_t getTileIndexBase() const; + inline ::uint64_t getTileIndexBase() const; inline bool hasTileOffsets() const; - inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileOffsets() const; + inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader + getTileOffsets() const; inline bool hasTileVarOffsets() const; - inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileVarOffsets() const; + inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader + getTileVarOffsets() const; inline bool hasTileVarSizes() const; - inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileVarSizes() const; + inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader + getTileVarSizes() const; inline bool hasTileValidityOffsets() const; - inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileValidityOffsets() const; + inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader + getTileValidityOffsets() const; inline bool hasTileMinBuffer() const; - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileMinBuffer() const; + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader + getTileMinBuffer() const; inline bool hasTileMinVarBuffer() const; - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileMinVarBuffer() const; + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader + getTileMinVarBuffer() const; inline bool hasTileMaxBuffer() const; - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileMaxBuffer() const; + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader + getTileMaxBuffer() const; inline bool hasTileMaxVarBuffer() const; - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileMaxVarBuffer() const; + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader + getTileMaxVarBuffer() const; inline bool hasTileSums() const; - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileSums() const; + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader + getTileSums() const; inline bool hasTileNullCounts() const; - inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getTileNullCounts() const; + inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader + getTileNullCounts() const; inline bool hasFragmentMins() const; - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getFragmentMins() const; + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader + getFragmentMins() const; inline bool hasFragmentMaxs() const; - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader getFragmentMaxs() const; + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader + getFragmentMaxs() const; inline bool hasFragmentSums() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getFragmentSums() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getFragmentSums() const; inline bool hasFragmentNullCounts() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getFragmentNullCounts() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getFragmentNullCounts() const; - inline ::uint32_t getVersion() const; + inline ::uint32_t getVersion() const; inline bool hasTimestampRange() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTimestampRange() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getTimestampRange() const; - inline ::uint64_t getLastTileCellNum() const; + inline ::uint64_t getLastTileCellNum() const; inline bool hasNonEmptyDomain() const; - inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader getNonEmptyDomain() const; + inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader + getNonEmptyDomain() const; inline bool hasRtree() const; - inline ::capnp::Data::Reader getRtree() const; + inline ::capnp::Data::Reader getRtree() const; inline bool getHasConsolidatedFooter() const; inline bool hasGtOffsets() const; - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Reader getGtOffsets() const; + inline ::tiledb::sm::serialization::capnp::FragmentMetadata:: + GenericTileOffsets::Reader + getGtOffsets() const; inline bool hasArraySchemaName() const; - inline ::capnp::Text::Reader getArraySchemaName() const; + inline ::capnp::Text::Reader getArraySchemaName() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -10253,51 +13251,80 @@ class FragmentMetadata::Reader { }; class FragmentMetadata::Builder { -public: + public: typedef FragmentMetadata Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasFileSizes(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getFileSizes(); - inline void setFileSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setFileSizes(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initFileSizes(unsigned int size); - inline void adoptFileSizes(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownFileSizes(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getFileSizes(); + inline void setFileSizes( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setFileSizes(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initFileSizes(unsigned int size); + inline void adoptFileSizes( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownFileSizes(); inline bool hasFileVarSizes(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getFileVarSizes(); - inline void setFileVarSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setFileVarSizes(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initFileVarSizes(unsigned int size); - inline void adoptFileVarSizes(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownFileVarSizes(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getFileVarSizes(); + inline void setFileVarSizes( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setFileVarSizes(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initFileVarSizes(unsigned int size); + inline void adoptFileVarSizes( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownFileVarSizes(); inline bool hasFileValiditySizes(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getFileValiditySizes(); - inline void setFileValiditySizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setFileValiditySizes(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initFileValiditySizes(unsigned int size); - inline void adoptFileValiditySizes(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownFileValiditySizes(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getFileValiditySizes(); + inline void setFileValiditySizes( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setFileValiditySizes(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initFileValiditySizes(unsigned int size); + inline void adoptFileValiditySizes( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownFileValiditySizes(); inline bool hasFragmentUri(); - inline ::capnp::Text::Builder getFragmentUri(); - inline void setFragmentUri( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initFragmentUri(unsigned int size); - inline void adoptFragmentUri(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownFragmentUri(); + inline ::capnp::Text::Builder getFragmentUri(); + inline void setFragmentUri(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initFragmentUri(unsigned int size); + inline void adoptFragmentUri(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownFragmentUri(); inline bool getHasTimestamps(); inline void setHasTimestamps(bool value); @@ -10305,170 +13332,419 @@ class FragmentMetadata::Builder { inline bool getHasDeleteMeta(); inline void setHasDeleteMeta(bool value); - inline ::uint64_t getSparseTileNum(); - inline void setSparseTileNum( ::uint64_t value); + inline ::uint64_t getSparseTileNum(); + inline void setSparseTileNum(::uint64_t value); - inline ::uint64_t getTileIndexBase(); - inline void setTileIndexBase( ::uint64_t value); + inline ::uint64_t getTileIndexBase(); + inline void setTileIndexBase(::uint64_t value); inline bool hasTileOffsets(); - inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileOffsets(); - inline void setTileOffsets( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); - inline void setTileOffsets(::kj::ArrayPtr::Reader> value); - inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileOffsets(unsigned int size); - inline void adoptTileOffsets(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileOffsets(); + inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + getTileOffsets(); + inline void setTileOffsets( + ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value); + inline void setTileOffsets( + ::kj::ArrayPtr< + const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> + value); + inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + initTileOffsets(unsigned int size); + inline void adoptTileOffsets( + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> + disownTileOffsets(); inline bool hasTileVarOffsets(); - inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileVarOffsets(); - inline void setTileVarOffsets( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); - inline void setTileVarOffsets(::kj::ArrayPtr::Reader> value); - inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileVarOffsets(unsigned int size); - inline void adoptTileVarOffsets(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileVarOffsets(); + inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + getTileVarOffsets(); + inline void setTileVarOffsets( + ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value); + inline void setTileVarOffsets( + ::kj::ArrayPtr< + const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> + value); + inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + initTileVarOffsets(unsigned int size); + inline void adoptTileVarOffsets( + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> + disownTileVarOffsets(); inline bool hasTileVarSizes(); - inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileVarSizes(); - inline void setTileVarSizes( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); - inline void setTileVarSizes(::kj::ArrayPtr::Reader> value); - inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileVarSizes(unsigned int size); - inline void adoptTileVarSizes(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileVarSizes(); + inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + getTileVarSizes(); + inline void setTileVarSizes( + ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value); + inline void setTileVarSizes( + ::kj::ArrayPtr< + const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> + value); + inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + initTileVarSizes(unsigned int size); + inline void adoptTileVarSizes( + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> + disownTileVarSizes(); inline bool hasTileValidityOffsets(); - inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileValidityOffsets(); - inline void setTileValidityOffsets( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); - inline void setTileValidityOffsets(::kj::ArrayPtr::Reader> value); - inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileValidityOffsets(unsigned int size); - inline void adoptTileValidityOffsets(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileValidityOffsets(); + inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + getTileValidityOffsets(); + inline void setTileValidityOffsets( + ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value); + inline void setTileValidityOffsets( + ::kj::ArrayPtr< + const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> + value); + inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + initTileValidityOffsets(unsigned int size); + inline void adoptTileValidityOffsets( + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> + disownTileValidityOffsets(); inline bool hasTileMinBuffer(); - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileMinBuffer(); - inline void setTileMinBuffer( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); - inline void setTileMinBuffer(::kj::ArrayPtr::Reader> value); - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileMinBuffer(unsigned int size); - inline void adoptTileMinBuffer(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileMinBuffer(); + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + getTileMinBuffer(); + inline void setTileMinBuffer( + ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value); + inline void setTileMinBuffer( + ::kj::ArrayPtr< + const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> + value); + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + initTileMinBuffer(unsigned int size); + inline void adoptTileMinBuffer( + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> + disownTileMinBuffer(); inline bool hasTileMinVarBuffer(); - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileMinVarBuffer(); - inline void setTileMinVarBuffer( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); - inline void setTileMinVarBuffer(::kj::ArrayPtr::Reader> value); - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileMinVarBuffer(unsigned int size); - inline void adoptTileMinVarBuffer(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileMinVarBuffer(); + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + getTileMinVarBuffer(); + inline void setTileMinVarBuffer( + ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value); + inline void setTileMinVarBuffer( + ::kj::ArrayPtr< + const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> + value); + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + initTileMinVarBuffer(unsigned int size); + inline void adoptTileMinVarBuffer( + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> + disownTileMinVarBuffer(); inline bool hasTileMaxBuffer(); - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileMaxBuffer(); - inline void setTileMaxBuffer( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); - inline void setTileMaxBuffer(::kj::ArrayPtr::Reader> value); - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileMaxBuffer(unsigned int size); - inline void adoptTileMaxBuffer(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileMaxBuffer(); + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + getTileMaxBuffer(); + inline void setTileMaxBuffer( + ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value); + inline void setTileMaxBuffer( + ::kj::ArrayPtr< + const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> + value); + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + initTileMaxBuffer(unsigned int size); + inline void adoptTileMaxBuffer( + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> + disownTileMaxBuffer(); inline bool hasTileMaxVarBuffer(); - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileMaxVarBuffer(); - inline void setTileMaxVarBuffer( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); - inline void setTileMaxVarBuffer(::kj::ArrayPtr::Reader> value); - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileMaxVarBuffer(unsigned int size); - inline void adoptTileMaxVarBuffer(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileMaxVarBuffer(); + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + getTileMaxVarBuffer(); + inline void setTileMaxVarBuffer( + ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value); + inline void setTileMaxVarBuffer( + ::kj::ArrayPtr< + const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> + value); + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + initTileMaxVarBuffer(unsigned int size); + inline void adoptTileMaxVarBuffer( + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> + disownTileMaxVarBuffer(); inline bool hasTileSums(); - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileSums(); - inline void setTileSums( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); - inline void setTileSums(::kj::ArrayPtr::Reader> value); - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileSums(unsigned int size); - inline void adoptTileSums(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileSums(); + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + getTileSums(); + inline void setTileSums(::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value); + inline void setTileSums( + ::kj::ArrayPtr< + const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> + value); + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + initTileSums(unsigned int size); + inline void adoptTileSums( + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> + disownTileSums(); inline bool hasTileNullCounts(); - inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getTileNullCounts(); - inline void setTileNullCounts( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); - inline void setTileNullCounts(::kj::ArrayPtr::Reader> value); - inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initTileNullCounts(unsigned int size); - inline void adoptTileNullCounts(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownTileNullCounts(); + inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + getTileNullCounts(); + inline void setTileNullCounts( + ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value); + inline void setTileNullCounts( + ::kj::ArrayPtr< + const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> + value); + inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + initTileNullCounts(unsigned int size); + inline void adoptTileNullCounts( + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> + disownTileNullCounts(); inline bool hasFragmentMins(); - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getFragmentMins(); - inline void setFragmentMins( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); - inline void setFragmentMins(::kj::ArrayPtr::Reader> value); - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initFragmentMins(unsigned int size); - inline void adoptFragmentMins(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownFragmentMins(); + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + getFragmentMins(); + inline void setFragmentMins( + ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value); + inline void setFragmentMins( + ::kj::ArrayPtr< + const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> + value); + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + initFragmentMins(unsigned int size); + inline void adoptFragmentMins( + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> + disownFragmentMins(); inline bool hasFragmentMaxs(); - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder getFragmentMaxs(); - inline void setFragmentMaxs( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value); - inline void setFragmentMaxs(::kj::ArrayPtr::Reader> value); - inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder initFragmentMaxs(unsigned int size); - inline void adoptFragmentMaxs(::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> disownFragmentMaxs(); + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + getFragmentMaxs(); + inline void setFragmentMaxs( + ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value); + inline void setFragmentMaxs( + ::kj::ArrayPtr< + const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> + value); + inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder + initFragmentMaxs(unsigned int size); + inline void adoptFragmentMaxs( + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> + disownFragmentMaxs(); inline bool hasFragmentSums(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getFragmentSums(); - inline void setFragmentSums( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setFragmentSums(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initFragmentSums(unsigned int size); - inline void adoptFragmentSums(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownFragmentSums(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getFragmentSums(); + inline void setFragmentSums( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setFragmentSums(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initFragmentSums(unsigned int size); + inline void adoptFragmentSums( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownFragmentSums(); inline bool hasFragmentNullCounts(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getFragmentNullCounts(); - inline void setFragmentNullCounts( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setFragmentNullCounts(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initFragmentNullCounts(unsigned int size); - inline void adoptFragmentNullCounts(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownFragmentNullCounts(); - - inline ::uint32_t getVersion(); - inline void setVersion( ::uint32_t value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getFragmentNullCounts(); + inline void setFragmentNullCounts( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setFragmentNullCounts(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initFragmentNullCounts(unsigned int size); + inline void adoptFragmentNullCounts( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownFragmentNullCounts(); + + inline ::uint32_t getVersion(); + inline void setVersion(::uint32_t value); inline bool hasTimestampRange(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTimestampRange(); - inline void setTimestampRange( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTimestampRange(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTimestampRange(unsigned int size); - inline void adoptTimestampRange(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTimestampRange(); - - inline ::uint64_t getLastTileCellNum(); - inline void setLastTileCellNum( ::uint64_t value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getTimestampRange(); + inline void setTimestampRange( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTimestampRange(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initTimestampRange(unsigned int size); + inline void adoptTimestampRange( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownTimestampRange(); + + inline ::uint64_t getLastTileCellNum(); + inline void setLastTileCellNum(::uint64_t value); inline bool hasNonEmptyDomain(); - inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder getNonEmptyDomain(); - inline void setNonEmptyDomain( ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader value); - inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder initNonEmptyDomain(); - inline void adoptNonEmptyDomain(::capnp::Orphan< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NonEmptyDomainList> disownNonEmptyDomain(); + inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder + getNonEmptyDomain(); + inline void setNonEmptyDomain( + ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader value); + inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder + initNonEmptyDomain(); + inline void adoptNonEmptyDomain( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::NonEmptyDomainList>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::NonEmptyDomainList> + disownNonEmptyDomain(); inline bool hasRtree(); - inline ::capnp::Data::Builder getRtree(); - inline void setRtree( ::capnp::Data::Reader value); - inline ::capnp::Data::Builder initRtree(unsigned int size); - inline void adoptRtree(::capnp::Orphan< ::capnp::Data>&& value); - inline ::capnp::Orphan< ::capnp::Data> disownRtree(); + inline ::capnp::Data::Builder getRtree(); + inline void setRtree(::capnp::Data::Reader value); + inline ::capnp::Data::Builder initRtree(unsigned int size); + inline void adoptRtree(::capnp::Orphan<::capnp::Data>&& value); + inline ::capnp::Orphan<::capnp::Data> disownRtree(); inline bool getHasConsolidatedFooter(); inline void setHasConsolidatedFooter(bool value); inline bool hasGtOffsets(); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Builder getGtOffsets(); - inline void setGtOffsets( ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Reader value); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Builder initGtOffsets(); - inline void adoptGtOffsets(::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets> disownGtOffsets(); + inline ::tiledb::sm::serialization::capnp::FragmentMetadata:: + GenericTileOffsets::Builder + getGtOffsets(); + inline void setGtOffsets( + ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets:: + Reader value); + inline ::tiledb::sm::serialization::capnp::FragmentMetadata:: + GenericTileOffsets::Builder + initGtOffsets(); + inline void adoptGtOffsets( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata:: + GenericTileOffsets>&& value); + inline ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets> + disownGtOffsets(); inline bool hasArraySchemaName(); - inline ::capnp::Text::Builder getArraySchemaName(); - inline void setArraySchemaName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initArraySchemaName(unsigned int size); - inline void adoptArraySchemaName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownArraySchemaName(); + inline ::capnp::Text::Builder getArraySchemaName(); + inline void setArraySchemaName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initArraySchemaName(unsigned int size); + inline void adoptArraySchemaName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownArraySchemaName(); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -10479,16 +13755,23 @@ class FragmentMetadata::Builder { #if !CAPNP_LITE class FragmentMetadata::Pipeline { -public: + public: typedef FragmentMetadata Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline getNonEmptyDomain(); - inline ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Pipeline getGtOffsets(); -private: + inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline + getNonEmptyDomain(); + inline ::tiledb::sm::serialization::capnp::FragmentMetadata:: + GenericTileOffsets::Pipeline + getGtOffsets(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -10497,11 +13780,13 @@ class FragmentMetadata::Pipeline { #endif // !CAPNP_LITE class FragmentMetadata::GenericTileOffsets::Reader { -public: + public: typedef GenericTileOffsets Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -10513,37 +13798,45 @@ class FragmentMetadata::GenericTileOffsets::Reader { } #endif // !CAPNP_LITE - inline ::uint64_t getRtree() const; + inline ::uint64_t getRtree() const; inline bool hasTileOffsets() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTileOffsets() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getTileOffsets() const; inline bool hasTileVarOffsets() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTileVarOffsets() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getTileVarOffsets() const; inline bool hasTileVarSizes() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTileVarSizes() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getTileVarSizes() const; inline bool hasTileValidityOffsets() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTileValidityOffsets() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getTileValidityOffsets() const; inline bool hasTileMinOffsets() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTileMinOffsets() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getTileMinOffsets() const; inline bool hasTileMaxOffsets() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTileMaxOffsets() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getTileMaxOffsets() const; inline bool hasTileSumOffsets() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTileSumOffsets() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getTileSumOffsets() const; inline bool hasTileNullCountOffsets() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTileNullCountOffsets() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getTileNullCountOffsets() const; - inline ::uint64_t getFragmentMinMaxSumNullCountOffset() const; + inline ::uint64_t getFragmentMinMaxSumNullCountOffset() const; - inline ::uint64_t getProcessedConditionsOffsets() const; + inline ::uint64_t getProcessedConditionsOffsets() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -10556,95 +13849,154 @@ class FragmentMetadata::GenericTileOffsets::Reader { }; class FragmentMetadata::GenericTileOffsets::Builder { -public: + public: typedef GenericTileOffsets Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE - inline ::uint64_t getRtree(); - inline void setRtree( ::uint64_t value); + inline ::uint64_t getRtree(); + inline void setRtree(::uint64_t value); inline bool hasTileOffsets(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTileOffsets(); - inline void setTileOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTileOffsets(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTileOffsets(unsigned int size); - inline void adoptTileOffsets(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTileOffsets(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getTileOffsets(); + inline void setTileOffsets( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTileOffsets(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initTileOffsets(unsigned int size); + inline void adoptTileOffsets( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownTileOffsets(); inline bool hasTileVarOffsets(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTileVarOffsets(); - inline void setTileVarOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTileVarOffsets(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTileVarOffsets(unsigned int size); - inline void adoptTileVarOffsets(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTileVarOffsets(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getTileVarOffsets(); + inline void setTileVarOffsets( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTileVarOffsets(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initTileVarOffsets(unsigned int size); + inline void adoptTileVarOffsets( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownTileVarOffsets(); inline bool hasTileVarSizes(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTileVarSizes(); - inline void setTileVarSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTileVarSizes(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTileVarSizes(unsigned int size); - inline void adoptTileVarSizes(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTileVarSizes(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getTileVarSizes(); + inline void setTileVarSizes( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTileVarSizes(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initTileVarSizes(unsigned int size); + inline void adoptTileVarSizes( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownTileVarSizes(); inline bool hasTileValidityOffsets(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTileValidityOffsets(); - inline void setTileValidityOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTileValidityOffsets(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTileValidityOffsets(unsigned int size); - inline void adoptTileValidityOffsets(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTileValidityOffsets(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getTileValidityOffsets(); + inline void setTileValidityOffsets( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTileValidityOffsets(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initTileValidityOffsets(unsigned int size); + inline void adoptTileValidityOffsets( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownTileValidityOffsets(); inline bool hasTileMinOffsets(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTileMinOffsets(); - inline void setTileMinOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTileMinOffsets(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTileMinOffsets(unsigned int size); - inline void adoptTileMinOffsets(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTileMinOffsets(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getTileMinOffsets(); + inline void setTileMinOffsets( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTileMinOffsets(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initTileMinOffsets(unsigned int size); + inline void adoptTileMinOffsets( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownTileMinOffsets(); inline bool hasTileMaxOffsets(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTileMaxOffsets(); - inline void setTileMaxOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTileMaxOffsets(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTileMaxOffsets(unsigned int size); - inline void adoptTileMaxOffsets(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTileMaxOffsets(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getTileMaxOffsets(); + inline void setTileMaxOffsets( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTileMaxOffsets(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initTileMaxOffsets(unsigned int size); + inline void adoptTileMaxOffsets( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownTileMaxOffsets(); inline bool hasTileSumOffsets(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTileSumOffsets(); - inline void setTileSumOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTileSumOffsets(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTileSumOffsets(unsigned int size); - inline void adoptTileSumOffsets(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTileSumOffsets(); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getTileSumOffsets(); + inline void setTileSumOffsets( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTileSumOffsets(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initTileSumOffsets(unsigned int size); + inline void adoptTileSumOffsets( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownTileSumOffsets(); inline bool hasTileNullCountOffsets(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTileNullCountOffsets(); - inline void setTileNullCountOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTileNullCountOffsets(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTileNullCountOffsets(unsigned int size); - inline void adoptTileNullCountOffsets(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTileNullCountOffsets(); - - inline ::uint64_t getFragmentMinMaxSumNullCountOffset(); - inline void setFragmentMinMaxSumNullCountOffset( ::uint64_t value); - - inline ::uint64_t getProcessedConditionsOffsets(); - inline void setProcessedConditionsOffsets( ::uint64_t value); - -private: + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getTileNullCountOffsets(); + inline void setTileNullCountOffsets( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTileNullCountOffsets(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initTileNullCountOffsets(unsigned int size); + inline void adoptTileNullCountOffsets( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownTileNullCountOffsets(); + + inline ::uint64_t getFragmentMinMaxSumNullCountOffset(); + inline void setFragmentMinMaxSumNullCountOffset(::uint64_t value); + + inline ::uint64_t getProcessedConditionsOffsets(); + inline void setProcessedConditionsOffsets(::uint64_t value); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -10655,14 +14007,17 @@ class FragmentMetadata::GenericTileOffsets::Builder { #if !CAPNP_LITE class FragmentMetadata::GenericTileOffsets::Pipeline { -public: + public: typedef GenericTileOffsets Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -10671,11 +14026,13 @@ class FragmentMetadata::GenericTileOffsets::Pipeline { #endif // !CAPNP_LITE class MultiPartUploadState::Reader { -public: + public: typedef MultiPartUploadState Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -10687,21 +14044,27 @@ class MultiPartUploadState::Reader { } #endif // !CAPNP_LITE - inline ::uint64_t getPartNumber() const; + inline ::uint64_t getPartNumber() const; inline bool hasUploadId() const; - inline ::capnp::Text::Reader getUploadId() const; + inline ::capnp::Text::Reader getUploadId() const; inline bool hasStatus() const; - inline ::capnp::Text::Reader getStatus() const; + inline ::capnp::Text::Reader getStatus() const; inline bool hasCompletedParts() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>::Reader getCompletedParts() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>::Reader + getCompletedParts() const; inline bool hasBufferedChunks() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>::Reader getBufferedChunks() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>::Reader + getBufferedChunks() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -10714,53 +14077,94 @@ class MultiPartUploadState::Reader { }; class MultiPartUploadState::Builder { -public: + public: typedef MultiPartUploadState Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE - inline ::uint64_t getPartNumber(); - inline void setPartNumber( ::uint64_t value); + inline ::uint64_t getPartNumber(); + inline void setPartNumber(::uint64_t value); inline bool hasUploadId(); - inline ::capnp::Text::Builder getUploadId(); - inline void setUploadId( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUploadId(unsigned int size); - inline void adoptUploadId(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownUploadId(); + inline ::capnp::Text::Builder getUploadId(); + inline void setUploadId(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUploadId(unsigned int size); + inline void adoptUploadId(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownUploadId(); inline bool hasStatus(); - inline ::capnp::Text::Builder getStatus(); - inline void setStatus( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initStatus(unsigned int size); - inline void adoptStatus(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownStatus(); + inline ::capnp::Text::Builder getStatus(); + inline void setStatus(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initStatus(unsigned int size); + inline void adoptStatus(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownStatus(); inline bool hasCompletedParts(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>::Builder getCompletedParts(); - inline void setCompletedParts( ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>::Builder initCompletedParts(unsigned int size); - inline void adoptCompletedParts(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>> disownCompletedParts(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>::Builder + getCompletedParts(); + inline void setCompletedParts( + ::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>::Builder + initCompletedParts(unsigned int size); + inline void adoptCompletedParts( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>> + disownCompletedParts(); inline bool hasBufferedChunks(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>::Builder getBufferedChunks(); - inline void setBufferedChunks( ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>::Builder initBufferedChunks(unsigned int size); - inline void adoptBufferedChunks(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>> disownBufferedChunks(); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>::Builder + getBufferedChunks(); + inline void setBufferedChunks( + ::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>::Builder + initBufferedChunks(unsigned int size); + inline void adoptBufferedChunks( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>> + disownBufferedChunks(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -10771,14 +14175,17 @@ class MultiPartUploadState::Builder { #if !CAPNP_LITE class MultiPartUploadState::Pipeline { -public: + public: typedef MultiPartUploadState Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -10787,11 +14194,13 @@ class MultiPartUploadState::Pipeline { #endif // !CAPNP_LITE class CompletedPart::Reader { -public: + public: typedef CompletedPart Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -10804,11 +14213,11 @@ class CompletedPart::Reader { #endif // !CAPNP_LITE inline bool hasETag() const; - inline ::capnp::Text::Reader getETag() const; + inline ::capnp::Text::Reader getETag() const; - inline ::uint64_t getPartNumber() const; + inline ::uint64_t getPartNumber() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -10821,32 +14230,43 @@ class CompletedPart::Reader { }; class CompletedPart::Builder { -public: + public: typedef CompletedPart Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasETag(); - inline ::capnp::Text::Builder getETag(); - inline void setETag( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initETag(unsigned int size); - inline void adoptETag(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownETag(); + inline ::capnp::Text::Builder getETag(); + inline void setETag(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initETag(unsigned int size); + inline void adoptETag(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownETag(); - inline ::uint64_t getPartNumber(); - inline void setPartNumber( ::uint64_t value); + inline ::uint64_t getPartNumber(); + inline void setPartNumber(::uint64_t value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -10857,14 +14277,17 @@ class CompletedPart::Builder { #if !CAPNP_LITE class CompletedPart::Pipeline { -public: + public: typedef CompletedPart Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -10873,11 +14296,13 @@ class CompletedPart::Pipeline { #endif // !CAPNP_LITE class WrittenFragmentInfo::Reader { -public: + public: typedef WrittenFragmentInfo Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -10890,12 +14315,13 @@ class WrittenFragmentInfo::Reader { #endif // !CAPNP_LITE inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; inline bool hasTimestampRange() const; - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader getTimestampRange() const; + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader + getTimestampRange() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -10908,37 +14334,54 @@ class WrittenFragmentInfo::Reader { }; class WrittenFragmentInfo::Builder { -public: + public: typedef WrittenFragmentInfo Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownUri(); inline bool hasTimestampRange(); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder getTimestampRange(); - inline void setTimestampRange( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); - inline void setTimestampRange(::kj::ArrayPtr value); - inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder initTimestampRange(unsigned int size); - inline void adoptTimestampRange(::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> disownTimestampRange(); - -private: + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + getTimestampRange(); + inline void setTimestampRange( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value); + inline void setTimestampRange(::kj::ArrayPtr value); + inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder + initTimestampRange(unsigned int size); + inline void adoptTimestampRange( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value); + inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> + disownTimestampRange(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -10949,14 +14392,17 @@ class WrittenFragmentInfo::Builder { #if !CAPNP_LITE class WrittenFragmentInfo::Pipeline { -public: + public: typedef WrittenFragmentInfo Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -10965,11 +14411,13 @@ class WrittenFragmentInfo::Pipeline { #endif // !CAPNP_LITE class BufferedChunk::Reader { -public: + public: typedef BufferedChunk Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -10982,11 +14430,11 @@ class BufferedChunk::Reader { #endif // !CAPNP_LITE inline bool hasUri() const; - inline ::capnp::Text::Reader getUri() const; + inline ::capnp::Text::Reader getUri() const; - inline ::uint64_t getSize() const; + inline ::uint64_t getSize() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -10999,32 +14447,43 @@ class BufferedChunk::Reader { }; class BufferedChunk::Builder { -public: + public: typedef BufferedChunk Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasUri(); - inline ::capnp::Text::Builder getUri(); - inline void setUri( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initUri(unsigned int size); - inline void adoptUri(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownUri(); + inline ::capnp::Text::Builder getUri(); + inline void setUri(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initUri(unsigned int size); + inline void adoptUri(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownUri(); - inline ::uint64_t getSize(); - inline void setSize( ::uint64_t value); + inline ::uint64_t getSize(); + inline void setSize(::uint64_t value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11035,14 +14494,17 @@ class BufferedChunk::Builder { #if !CAPNP_LITE class BufferedChunk::Pipeline { -public: + public: typedef BufferedChunk Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11051,11 +14513,13 @@ class BufferedChunk::Pipeline { #endif // !CAPNP_LITE class ArrayDeleteFragmentsListRequest::Reader { -public: + public: typedef ArrayDeleteFragmentsListRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11068,12 +14532,13 @@ class ArrayDeleteFragmentsListRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasEntries() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getEntries() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader getEntries() + const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11086,37 +14551,57 @@ class ArrayDeleteFragmentsListRequest::Reader { }; class ArrayDeleteFragmentsListRequest::Builder { -public: + public: typedef ArrayDeleteFragmentsListRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> + disownConfig(); inline bool hasEntries(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getEntries(); - inline void setEntries( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setEntries(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initEntries(unsigned int size); - inline void adoptEntries(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownEntries(); - -private: + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getEntries(); + inline void setEntries( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setEntries(::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder initEntries( + unsigned int size); + inline void adoptEntries( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownEntries(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11127,15 +14612,19 @@ class ArrayDeleteFragmentsListRequest::Builder { #if !CAPNP_LITE class ArrayDeleteFragmentsListRequest::Pipeline { -public: + public: typedef ArrayDeleteFragmentsListRequest Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11144,11 +14633,13 @@ class ArrayDeleteFragmentsListRequest::Pipeline { #endif // !CAPNP_LITE class ArrayDeleteFragmentsTimestampsRequest::Reader { -public: + public: typedef ArrayDeleteFragmentsTimestampsRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11161,13 +14652,13 @@ class ArrayDeleteFragmentsTimestampsRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; - inline ::uint64_t getStartTimestamp() const; + inline ::uint64_t getStartTimestamp() const; - inline ::uint64_t getEndTimestamp() const; + inline ::uint64_t getEndTimestamp() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11180,35 +14671,49 @@ class ArrayDeleteFragmentsTimestampsRequest::Reader { }; class ArrayDeleteFragmentsTimestampsRequest::Builder { -public: + public: typedef ArrayDeleteFragmentsTimestampsRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); - - inline ::uint64_t getStartTimestamp(); - inline void setStartTimestamp( ::uint64_t value); - - inline ::uint64_t getEndTimestamp(); - inline void setEndTimestamp( ::uint64_t value); - -private: + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> + disownConfig(); + + inline ::uint64_t getStartTimestamp(); + inline void setStartTimestamp(::uint64_t value); + + inline ::uint64_t getEndTimestamp(); + inline void setEndTimestamp(::uint64_t value); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11219,15 +14724,19 @@ class ArrayDeleteFragmentsTimestampsRequest::Builder { #if !CAPNP_LITE class ArrayDeleteFragmentsTimestampsRequest::Pipeline { -public: + public: typedef ArrayDeleteFragmentsTimestampsRequest Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); -private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11236,11 +14745,13 @@ class ArrayDeleteFragmentsTimestampsRequest::Pipeline { #endif // !CAPNP_LITE class ArrayConsolidationRequest::Reader { -public: + public: typedef ArrayConsolidationRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11253,12 +14764,13 @@ class ArrayConsolidationRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasFragments() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getFragments() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getFragments() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11271,37 +14783,57 @@ class ArrayConsolidationRequest::Reader { }; class ArrayConsolidationRequest::Builder { -public: + public: typedef ArrayConsolidationRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> + disownConfig(); inline bool hasFragments(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getFragments(); - inline void setFragments( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setFragments(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initFragments(unsigned int size); - inline void adoptFragments(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownFragments(); - -private: + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getFragments(); + inline void setFragments( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setFragments(::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initFragments(unsigned int size); + inline void adoptFragments( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownFragments(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11312,15 +14844,19 @@ class ArrayConsolidationRequest::Builder { #if !CAPNP_LITE class ArrayConsolidationRequest::Pipeline { -public: + public: typedef ArrayConsolidationRequest Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); -private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11329,11 +14865,13 @@ class ArrayConsolidationRequest::Pipeline { #endif // !CAPNP_LITE class ArrayVacuumRequest::Reader { -public: + public: typedef ArrayVacuumRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11346,9 +14884,9 @@ class ArrayVacuumRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11361,29 +14899,43 @@ class ArrayVacuumRequest::Reader { }; class ArrayVacuumRequest::Builder { -public: + public: typedef ArrayVacuumRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); - -private: + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> + disownConfig(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11394,15 +14946,19 @@ class ArrayVacuumRequest::Builder { #if !CAPNP_LITE class ArrayVacuumRequest::Pipeline { -public: + public: typedef ArrayVacuumRequest Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11411,11 +14967,13 @@ class ArrayVacuumRequest::Pipeline { #endif // !CAPNP_LITE class LoadEnumerationsRequest::Reader { -public: + public: typedef LoadEnumerationsRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11428,12 +14986,13 @@ class LoadEnumerationsRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasEnumerations() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getEnumerations() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getEnumerations() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11446,37 +15005,58 @@ class LoadEnumerationsRequest::Reader { }; class LoadEnumerationsRequest::Builder { -public: + public: typedef LoadEnumerationsRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> + disownConfig(); inline bool hasEnumerations(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getEnumerations(); - inline void setEnumerations( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setEnumerations(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initEnumerations(unsigned int size); - inline void adoptEnumerations(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownEnumerations(); - -private: + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getEnumerations(); + inline void setEnumerations( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setEnumerations( + ::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initEnumerations(unsigned int size); + inline void adoptEnumerations( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownEnumerations(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11487,15 +15067,19 @@ class LoadEnumerationsRequest::Builder { #if !CAPNP_LITE class LoadEnumerationsRequest::Pipeline { -public: + public: typedef LoadEnumerationsRequest Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11504,11 +15088,13 @@ class LoadEnumerationsRequest::Pipeline { #endif // !CAPNP_LITE class LoadEnumerationsResponse::Reader { -public: + public: typedef LoadEnumerationsResponse Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11521,12 +15107,16 @@ class LoadEnumerationsResponse::Reader { #endif // !CAPNP_LITE inline bool hasEnumerations() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader getEnumerations() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader + getEnumerations() const; inline bool hasAllEnumerations() const; - inline ::tiledb::sm::serialization::capnp::MapEnumeration::Reader getAllEnumerations() const; + inline ::tiledb::sm::serialization::capnp::MapEnumeration::Reader + getAllEnumerations() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11539,36 +15129,67 @@ class LoadEnumerationsResponse::Reader { }; class LoadEnumerationsResponse::Builder { -public: + public: typedef LoadEnumerationsResponse Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } -#endif // !CAPNP_LITE + inline ::kj::StringTree toString() const { + return asReader().toString(); + } +#endif // !CAPNP_LITE inline bool hasEnumerations(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder getEnumerations(); - inline void setEnumerations( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder initEnumerations(unsigned int size); - inline void adoptEnumerations(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> disownEnumerations(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder + getEnumerations(); + inline void setEnumerations(::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder + initEnumerations(unsigned int size); + inline void adoptEnumerations( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>> + disownEnumerations(); inline bool hasAllEnumerations(); - inline ::tiledb::sm::serialization::capnp::MapEnumeration::Builder getAllEnumerations(); - inline void setAllEnumerations( ::tiledb::sm::serialization::capnp::MapEnumeration::Reader value); - inline ::tiledb::sm::serialization::capnp::MapEnumeration::Builder initAllEnumerations(); - inline void adoptAllEnumerations(::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapEnumeration>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapEnumeration> disownAllEnumerations(); - -private: + inline ::tiledb::sm::serialization::capnp::MapEnumeration::Builder + getAllEnumerations(); + inline void setAllEnumerations( + ::tiledb::sm::serialization::capnp::MapEnumeration::Reader value); + inline ::tiledb::sm::serialization::capnp::MapEnumeration::Builder + initAllEnumerations(); + inline void adoptAllEnumerations( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapEnumeration>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapEnumeration> + disownAllEnumerations(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11579,15 +15200,20 @@ class LoadEnumerationsResponse::Builder { #if !CAPNP_LITE class LoadEnumerationsResponse::Pipeline { -public: + public: typedef LoadEnumerationsResponse Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::MapEnumeration::Pipeline getAllEnumerations(); -private: + inline ::tiledb::sm::serialization::capnp::MapEnumeration::Pipeline + getAllEnumerations(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11596,11 +15222,13 @@ class LoadEnumerationsResponse::Pipeline { #endif // !CAPNP_LITE class LoadArraySchemaRequest::Reader { -public: + public: typedef LoadArraySchemaRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11613,11 +15241,11 @@ class LoadArraySchemaRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool getIncludeEnumerations() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11630,32 +15258,46 @@ class LoadArraySchemaRequest::Reader { }; class LoadArraySchemaRequest::Builder { -public: + public: typedef LoadArraySchemaRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> + disownConfig(); inline bool getIncludeEnumerations(); inline void setIncludeEnumerations(bool value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11666,15 +15308,19 @@ class LoadArraySchemaRequest::Builder { #if !CAPNP_LITE class LoadArraySchemaRequest::Pipeline { -public: + public: typedef LoadArraySchemaRequest Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); -private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11683,11 +15329,13 @@ class LoadArraySchemaRequest::Pipeline { #endif // !CAPNP_LITE class LoadArraySchemaResponse::Reader { -public: + public: typedef LoadArraySchemaResponse Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11700,12 +15348,16 @@ class LoadArraySchemaResponse::Reader { #endif // !CAPNP_LITE inline bool hasSchema() const; - inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader getSchema() const; + inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader getSchema() + const; inline bool hasArraySchemasAll() const; - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader getArraySchemasAll() const; + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Reader + getArraySchemasAll() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11718,36 +15370,65 @@ class LoadArraySchemaResponse::Reader { }; class LoadArraySchemaResponse::Builder { -public: + public: typedef LoadArraySchemaResponse Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasSchema(); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder getSchema(); - inline void setSchema( ::tiledb::sm::serialization::capnp::ArraySchema::Reader value); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder initSchema(); - inline void adoptSchema(::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema> disownSchema(); + inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder getSchema(); + inline void setSchema( + ::tiledb::sm::serialization::capnp::ArraySchema::Reader value); + inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder initSchema(); + inline void adoptSchema( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema> + disownSchema(); inline bool hasArraySchemasAll(); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder getArraySchemasAll(); - inline void setArraySchemasAll( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder initArraySchemasAll(); - inline void adoptArraySchemasAll(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>> disownArraySchemasAll(); - -private: + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Builder + getArraySchemasAll(); + inline void setArraySchemasAll( + ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value); + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Builder + initArraySchemasAll(); + inline void adoptArraySchemasAll( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>> + disownArraySchemasAll(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11758,16 +15439,23 @@ class LoadArraySchemaResponse::Builder { #if !CAPNP_LITE class LoadArraySchemaResponse::Pipeline { -public: + public: typedef LoadArraySchemaResponse Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline getSchema(); + inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline + getArraySchemasAll(); - inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline getSchema(); - inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline getArraySchemasAll(); -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11776,11 +15464,13 @@ class LoadArraySchemaResponse::Pipeline { #endif // !CAPNP_LITE class QueryPlanRequest::Reader { -public: + public: typedef QueryPlanRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11793,12 +15483,12 @@ class QueryPlanRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; inline bool hasQuery() const; - inline ::tiledb::sm::serialization::capnp::Query::Reader getQuery() const; + inline ::tiledb::sm::serialization::capnp::Query::Reader getQuery() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11811,36 +15501,52 @@ class QueryPlanRequest::Reader { }; class QueryPlanRequest::Builder { -public: + public: typedef QueryPlanRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> + disownConfig(); inline bool hasQuery(); - inline ::tiledb::sm::serialization::capnp::Query::Builder getQuery(); - inline void setQuery( ::tiledb::sm::serialization::capnp::Query::Reader value); - inline ::tiledb::sm::serialization::capnp::Query::Builder initQuery(); - inline void adoptQuery(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Query>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Query> disownQuery(); - -private: + inline ::tiledb::sm::serialization::capnp::Query::Builder getQuery(); + inline void setQuery(::tiledb::sm::serialization::capnp::Query::Reader value); + inline ::tiledb::sm::serialization::capnp::Query::Builder initQuery(); + inline void adoptQuery( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Query>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Query> + disownQuery(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11851,16 +15557,20 @@ class QueryPlanRequest::Builder { #if !CAPNP_LITE class QueryPlanRequest::Pipeline { -public: + public: typedef QueryPlanRequest Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::Query::Pipeline getQuery(); -private: + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); + inline ::tiledb::sm::serialization::capnp::Query::Pipeline getQuery(); + + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11869,11 +15579,13 @@ class QueryPlanRequest::Pipeline { #endif // !CAPNP_LITE class QueryPlanResponse::Reader { -public: + public: typedef QueryPlanResponse Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -11886,21 +15598,23 @@ class QueryPlanResponse::Reader { #endif // !CAPNP_LITE inline bool hasQueryLayout() const; - inline ::capnp::Text::Reader getQueryLayout() const; + inline ::capnp::Text::Reader getQueryLayout() const; inline bool hasStrategyName() const; - inline ::capnp::Text::Reader getStrategyName() const; + inline ::capnp::Text::Reader getStrategyName() const; inline bool hasArrayType() const; - inline ::capnp::Text::Reader getArrayType() const; + inline ::capnp::Text::Reader getArrayType() const; inline bool hasAttributeNames() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getAttributeNames() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getAttributeNames() const; inline bool hasDimensionNames() const; - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader getDimensionNames() const; + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader + getDimensionNames() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -11913,59 +15627,84 @@ class QueryPlanResponse::Reader { }; class QueryPlanResponse::Builder { -public: + public: typedef QueryPlanResponse Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasQueryLayout(); - inline ::capnp::Text::Builder getQueryLayout(); - inline void setQueryLayout( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initQueryLayout(unsigned int size); - inline void adoptQueryLayout(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownQueryLayout(); + inline ::capnp::Text::Builder getQueryLayout(); + inline void setQueryLayout(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initQueryLayout(unsigned int size); + inline void adoptQueryLayout(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownQueryLayout(); inline bool hasStrategyName(); - inline ::capnp::Text::Builder getStrategyName(); - inline void setStrategyName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initStrategyName(unsigned int size); - inline void adoptStrategyName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownStrategyName(); + inline ::capnp::Text::Builder getStrategyName(); + inline void setStrategyName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initStrategyName(unsigned int size); + inline void adoptStrategyName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownStrategyName(); inline bool hasArrayType(); - inline ::capnp::Text::Builder getArrayType(); - inline void setArrayType( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initArrayType(unsigned int size); - inline void adoptArrayType(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownArrayType(); + inline ::capnp::Text::Builder getArrayType(); + inline void setArrayType(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initArrayType(unsigned int size); + inline void adoptArrayType(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownArrayType(); inline bool hasAttributeNames(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getAttributeNames(); - inline void setAttributeNames( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setAttributeNames(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initAttributeNames(unsigned int size); - inline void adoptAttributeNames(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownAttributeNames(); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getAttributeNames(); + inline void setAttributeNames( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setAttributeNames( + ::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initAttributeNames(unsigned int size); + inline void adoptAttributeNames( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownAttributeNames(); inline bool hasDimensionNames(); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder getDimensionNames(); - inline void setDimensionNames( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value); - inline void setDimensionNames(::kj::ArrayPtr value); - inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder initDimensionNames(unsigned int size); - inline void adoptDimensionNames(::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> disownDimensionNames(); - -private: + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + getDimensionNames(); + inline void setDimensionNames( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value); + inline void setDimensionNames( + ::kj::ArrayPtr value); + inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder + initDimensionNames(unsigned int size); + inline void adoptDimensionNames( + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value); + inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> + disownDimensionNames(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -11976,14 +15715,17 @@ class QueryPlanResponse::Builder { #if !CAPNP_LITE class QueryPlanResponse::Pipeline { -public: + public: typedef QueryPlanResponse Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -11992,11 +15734,13 @@ class QueryPlanResponse::Pipeline { #endif // !CAPNP_LITE class ConsolidationPlanRequest::Reader { -public: + public: typedef ConsolidationPlanRequest Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -12009,11 +15753,11 @@ class ConsolidationPlanRequest::Reader { #endif // !CAPNP_LITE inline bool hasConfig() const; - inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; + inline ::tiledb::sm::serialization::capnp::Config::Reader getConfig() const; - inline ::uint64_t getFragmentSize() const; + inline ::uint64_t getFragmentSize() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -12026,32 +15770,46 @@ class ConsolidationPlanRequest::Reader { }; class ConsolidationPlanRequest::Builder { -public: + public: typedef ConsolidationPlanRequest Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); - inline void setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value); - inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); - inline void adoptConfig(::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> disownConfig(); - - inline ::uint64_t getFragmentSize(); - inline void setFragmentSize( ::uint64_t value); - -private: + inline ::tiledb::sm::serialization::capnp::Config::Builder getConfig(); + inline void setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value); + inline ::tiledb::sm::serialization::capnp::Config::Builder initConfig(); + inline void adoptConfig( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> + disownConfig(); + + inline ::uint64_t getFragmentSize(); + inline void setFragmentSize(::uint64_t value); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -12062,15 +15820,19 @@ class ConsolidationPlanRequest::Builder { #if !CAPNP_LITE class ConsolidationPlanRequest::Pipeline { -public: + public: typedef ConsolidationPlanRequest Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); - inline ::tiledb::sm::serialization::capnp::Config::Pipeline getConfig(); -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -12079,11 +15841,13 @@ class ConsolidationPlanRequest::Pipeline { #endif // !CAPNP_LITE class ConsolidationPlanResponse::Reader { -public: + public: typedef ConsolidationPlanResponse Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -12096,9 +15860,12 @@ class ConsolidationPlanResponse::Reader { #endif // !CAPNP_LITE inline bool hasFragmentUrisPerNode() const; - inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Reader getFragmentUrisPerNode() const; + inline ::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>::Reader + getFragmentUrisPerNode() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -12111,30 +15878,59 @@ class ConsolidationPlanResponse::Reader { }; class ConsolidationPlanResponse::Builder { -public: + public: typedef ConsolidationPlanResponse Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasFragmentUrisPerNode(); - inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Builder getFragmentUrisPerNode(); - inline void setFragmentUrisPerNode( ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Reader value); - inline void setFragmentUrisPerNode(::kj::ArrayPtr::Reader> value); - inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Builder initFragmentUrisPerNode(unsigned int size); - inline void adoptFragmentUrisPerNode(::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>> disownFragmentUrisPerNode(); - -private: + inline ::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>::Builder + getFragmentUrisPerNode(); + inline void setFragmentUrisPerNode( + ::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>::Reader value); + inline void setFragmentUrisPerNode( + ::kj::ArrayPtr< + const ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader> + value); + inline ::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>::Builder + initFragmentUrisPerNode(unsigned int size); + inline void adoptFragmentUrisPerNode( + ::capnp::Orphan<::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>> + disownFragmentUrisPerNode(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -12145,14 +15941,17 @@ class ConsolidationPlanResponse::Builder { #if !CAPNP_LITE class ConsolidationPlanResponse::Pipeline { -public: + public: typedef ConsolidationPlanResponse Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -12161,11 +15960,13 @@ class ConsolidationPlanResponse::Pipeline { #endif // !CAPNP_LITE class QueryChannel::Reader { -public: + public: typedef QueryChannel Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -12180,9 +15981,12 @@ class QueryChannel::Reader { inline bool getDefault() const; inline bool hasAggregates() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>::Reader getAggregates() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>::Reader + getAggregates() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -12195,32 +15999,56 @@ class QueryChannel::Reader { }; class QueryChannel::Builder { -public: + public: typedef QueryChannel Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool getDefault(); inline void setDefault(bool value); inline bool hasAggregates(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>::Builder getAggregates(); - inline void setAggregates( ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>::Builder initAggregates(unsigned int size); - inline void adoptAggregates(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>> disownAggregates(); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>::Builder + getAggregates(); + inline void setAggregates(::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>::Builder + initAggregates(unsigned int size); + inline void adoptAggregates(::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>> + disownAggregates(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -12231,14 +16059,17 @@ class QueryChannel::Builder { #if !CAPNP_LITE class QueryChannel::Pipeline { -public: + public: typedef QueryChannel Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -12247,11 +16078,13 @@ class QueryChannel::Pipeline { #endif // !CAPNP_LITE class Aggregate::Reader { -public: + public: typedef Aggregate Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -12264,15 +16097,15 @@ class Aggregate::Reader { #endif // !CAPNP_LITE inline bool hasOutputFieldName() const; - inline ::capnp::Text::Reader getOutputFieldName() const; + inline ::capnp::Text::Reader getOutputFieldName() const; inline bool hasInputFieldName() const; - inline ::capnp::Text::Reader getInputFieldName() const; + inline ::capnp::Text::Reader getInputFieldName() const; inline bool hasName() const; - inline ::capnp::Text::Reader getName() const; + inline ::capnp::Text::Reader getName() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -12285,43 +16118,54 @@ class Aggregate::Reader { }; class Aggregate::Builder { -public: + public: typedef Aggregate Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasOutputFieldName(); - inline ::capnp::Text::Builder getOutputFieldName(); - inline void setOutputFieldName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initOutputFieldName(unsigned int size); - inline void adoptOutputFieldName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownOutputFieldName(); + inline ::capnp::Text::Builder getOutputFieldName(); + inline void setOutputFieldName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initOutputFieldName(unsigned int size); + inline void adoptOutputFieldName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownOutputFieldName(); inline bool hasInputFieldName(); - inline ::capnp::Text::Builder getInputFieldName(); - inline void setInputFieldName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initInputFieldName(unsigned int size); - inline void adoptInputFieldName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownInputFieldName(); + inline ::capnp::Text::Builder getInputFieldName(); + inline void setInputFieldName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initInputFieldName(unsigned int size); + inline void adoptInputFieldName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownInputFieldName(); inline bool hasName(); - inline ::capnp::Text::Builder getName(); - inline void setName( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initName(unsigned int size); - inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownName(); + inline ::capnp::Text::Builder getName(); + inline void setName(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initName(unsigned int size); + inline void adoptName(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownName(); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -12332,14 +16176,17 @@ class Aggregate::Builder { #if !CAPNP_LITE class Aggregate::Pipeline { -public: + public: typedef Aggregate Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -12348,11 +16195,13 @@ class Aggregate::Pipeline { #endif // !CAPNP_LITE class CurrentDomain::Reader { -public: + public: typedef CurrentDomain Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -12365,19 +16214,20 @@ class CurrentDomain::Reader { #endif // !CAPNP_LITE inline Which which() const; - inline ::uint32_t getVersion() const; + inline ::uint32_t getVersion() const; inline bool hasType() const; - inline ::capnp::Text::Reader getType() const; + inline ::capnp::Text::Reader getType() const; inline bool isEmptyCurrentDomain() const; - inline ::capnp::Void getEmptyCurrentDomain() const; + inline ::capnp::Void getEmptyCurrentDomain() const; inline bool isNdRectangle() const; inline bool hasNdRectangle() const; - inline ::tiledb::sm::serialization::capnp::NDRectangle::Reader getNdRectangle() const; + inline ::tiledb::sm::serialization::capnp::NDRectangle::Reader + getNdRectangle() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -12390,45 +16240,61 @@ class CurrentDomain::Reader { }; class CurrentDomain::Builder { -public: + public: typedef CurrentDomain Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline Which which(); - inline ::uint32_t getVersion(); - inline void setVersion( ::uint32_t value); + inline ::uint32_t getVersion(); + inline void setVersion(::uint32_t value); inline bool hasType(); - inline ::capnp::Text::Builder getType(); - inline void setType( ::capnp::Text::Reader value); - inline ::capnp::Text::Builder initType(unsigned int size); - inline void adoptType(::capnp::Orphan< ::capnp::Text>&& value); - inline ::capnp::Orphan< ::capnp::Text> disownType(); + inline ::capnp::Text::Builder getType(); + inline void setType(::capnp::Text::Reader value); + inline ::capnp::Text::Builder initType(unsigned int size); + inline void adoptType(::capnp::Orphan<::capnp::Text>&& value); + inline ::capnp::Orphan<::capnp::Text> disownType(); inline bool isEmptyCurrentDomain(); - inline ::capnp::Void getEmptyCurrentDomain(); - inline void setEmptyCurrentDomain( ::capnp::Void value = ::capnp::VOID); + inline ::capnp::Void getEmptyCurrentDomain(); + inline void setEmptyCurrentDomain(::capnp::Void value = ::capnp::VOID); inline bool isNdRectangle(); inline bool hasNdRectangle(); - inline ::tiledb::sm::serialization::capnp::NDRectangle::Builder getNdRectangle(); - inline void setNdRectangle( ::tiledb::sm::serialization::capnp::NDRectangle::Reader value); - inline ::tiledb::sm::serialization::capnp::NDRectangle::Builder initNdRectangle(); - inline void adoptNdRectangle(::capnp::Orphan< ::tiledb::sm::serialization::capnp::NDRectangle>&& value); - inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NDRectangle> disownNdRectangle(); - -private: + inline ::tiledb::sm::serialization::capnp::NDRectangle::Builder + getNdRectangle(); + inline void setNdRectangle( + ::tiledb::sm::serialization::capnp::NDRectangle::Reader value); + inline ::tiledb::sm::serialization::capnp::NDRectangle::Builder + initNdRectangle(); + inline void adoptNdRectangle( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::NDRectangle>&& value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::NDRectangle> + disownNdRectangle(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -12439,14 +16305,17 @@ class CurrentDomain::Builder { #if !CAPNP_LITE class CurrentDomain::Pipeline { -public: + public: typedef CurrentDomain Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -12455,11 +16324,13 @@ class CurrentDomain::Pipeline { #endif // !CAPNP_LITE class NDRectangle::Reader { -public: + public: typedef NDRectangle Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -12472,9 +16343,12 @@ class NDRectangle::Reader { #endif // !CAPNP_LITE inline bool hasNdranges() const; - inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Reader getNdranges() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>::Reader + getNdranges() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -12487,29 +16361,54 @@ class NDRectangle::Reader { }; class NDRectangle::Builder { -public: + public: typedef NDRectangle Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE inline bool hasNdranges(); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Builder getNdranges(); - inline void setNdranges( ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Builder initNdranges(unsigned int size); - inline void adoptNdranges(::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>> disownNdranges(); - -private: + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>::Builder + getNdranges(); + inline void setNdranges(::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>::Builder + initNdranges(unsigned int size); + inline void adoptNdranges( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>> + disownNdranges(); + + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -12520,14 +16419,17 @@ class NDRectangle::Builder { #if !CAPNP_LITE class NDRectangle::Pipeline { -public: + public: typedef NDRectangle Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -12536,11 +16438,13 @@ class NDRectangle::Pipeline { #endif // !CAPNP_LITE class ObjectInfoResponse::Reader { -public: + public: typedef ObjectInfoResponse Reads; Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } inline ::capnp::MessageSize totalSize() const { return _reader.totalSize().asPublic(); @@ -12552,9 +16456,9 @@ class ObjectInfoResponse::Reader { } #endif // !CAPNP_LITE - inline ::tiledb::sm::serialization::capnp::ObjectType getObjectType() const; + inline ::tiledb::sm::serialization::capnp::ObjectType getObjectType() const; -private: + private: ::capnp::_::StructReader _reader; template friend struct ::capnp::ToDynamic_; @@ -12567,25 +16471,37 @@ class ObjectInfoResponse::Reader { }; class ObjectInfoResponse::Builder { -public: + public: typedef ObjectInfoResponse Builds; Builder() = delete; // Deleted to discourage incorrect usage. // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) {} - inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} - inline operator Reader() const { return Reader(_builder.asReader()); } - inline Reader asReader() const { return *this; } + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } - inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } #if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } + inline ::kj::StringTree toString() const { + return asReader().toString(); + } #endif // !CAPNP_LITE - inline ::tiledb::sm::serialization::capnp::ObjectType getObjectType(); - inline void setObjectType( ::tiledb::sm::serialization::capnp::ObjectType value); + inline ::tiledb::sm::serialization::capnp::ObjectType getObjectType(); + inline void setObjectType( + ::tiledb::sm::serialization::capnp::ObjectType value); -private: + private: ::capnp::_::StructBuilder _builder; template friend struct ::capnp::ToDynamic_; @@ -12596,14 +16512,17 @@ class ObjectInfoResponse::Builder { #if !CAPNP_LITE class ObjectInfoResponse::Pipeline { -public: + public: typedef ObjectInfoResponse Pipelines; - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} + : _typeless(kj::mv(typeless)) { + } -private: + private: ::capnp::AnyPointer::Pipeline _typeless; friend class ::capnp::PipelineHook; template @@ -12614,1241 +16533,1747 @@ class ObjectInfoResponse::Pipeline { // ======================================================================================= inline bool DomainArray::Reader::hasInt8() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool DomainArray::Builder::hasInt8() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Reader DomainArray::Reader::getInt8() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::getInt8() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setInt8( ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline void DomainArray::Builder::setInt8(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::initInt8(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>::Reader +DomainArray::Reader::getInt8() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>::Builder +DomainArray::Builder::getInt8() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setInt8( + ::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline void DomainArray::Builder::setInt8( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>::Builder +DomainArray::Builder::initInt8(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void DomainArray::Builder::adoptInt8( - ::capnp::Orphan< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>> DomainArray::Builder::disownInt8() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>> +DomainArray::Builder::disownInt8() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::int8_t, ::capnp::Kind::PRIMITIVE>>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasUint8() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool DomainArray::Builder::hasUint8() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader DomainArray::Reader::getUint8() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::getUint8() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setUint8( ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline void DomainArray::Builder::setUint8(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::initUint8(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader +DomainArray::Reader::getUint8() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder +DomainArray::Builder::getUint8() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setUint8( + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline void DomainArray::Builder::setUint8( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Builder +DomainArray::Builder::initUint8(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void DomainArray::Builder::adoptUint8( - ::capnp::Orphan< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>> DomainArray::Builder::disownUint8() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>> +DomainArray::Builder::disownUint8() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasInt16() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool DomainArray::Builder::hasInt16() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Reader DomainArray::Reader::getInt16() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::getInt16() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setInt16( ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline void DomainArray::Builder::setInt16(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::initInt16(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>::Reader +DomainArray::Reader::getInt16() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>::Builder +DomainArray::Builder::getInt16() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setInt16( + ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline void DomainArray::Builder::setInt16( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>::Builder +DomainArray::Builder::initInt16(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void DomainArray::Builder::adoptInt16( - ::capnp::Orphan< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>::adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>> DomainArray::Builder::disownInt16() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>> +DomainArray::Builder::disownInt16() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::int16_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasUint16() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool DomainArray::Builder::hasUint16() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader DomainArray::Reader::getUint16() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::getUint16() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setUint16( ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline void DomainArray::Builder::setUint16(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::initUint16(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader +DomainArray::Reader::getUint16() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder +DomainArray::Builder::getUint16() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setUint16( + ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline void DomainArray::Builder::setUint16( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>::Builder +DomainArray::Builder::initUint16(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + size); } inline void DomainArray::Builder::adoptUint16( - ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>> DomainArray::Builder::disownUint16() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>> +DomainArray::Builder::disownUint16() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint16_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasInt32() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool DomainArray::Builder::hasInt32() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader DomainArray::Reader::getInt32() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::getInt32() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setInt32( ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); -} -inline void DomainArray::Builder::setInt32(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::initInt32(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Reader +DomainArray::Reader::getInt32() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Builder +DomainArray::Builder::getInt32() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setInt32( + ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); +} +inline void DomainArray::Builder::setInt32( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Builder +DomainArray::Builder::initInt32(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + size); } inline void DomainArray::Builder::adoptInt32( - ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>> DomainArray::Builder::disownInt32() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>> +DomainArray::Builder::disownInt32() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasUint32() const { - return !_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } inline bool DomainArray::Builder::hasUint32() { - return !_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader DomainArray::Reader::getUint32() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::getUint32() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setUint32( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), value); -} -inline void DomainArray::Builder::setUint32(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::initUint32(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader +DomainArray::Reader::getUint32() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder +DomainArray::Builder::getUint32() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setUint32( + ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + value); +} +inline void DomainArray::Builder::setUint32( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder +DomainArray::Builder::initUint32(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + size); } inline void DomainArray::Builder::adoptUint32( - ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> DomainArray::Builder::disownUint32() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>> +DomainArray::Builder::disownUint32() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasInt64() const { - return !_reader.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) + .isNull(); } inline bool DomainArray::Builder::hasInt64() { - return !_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader DomainArray::Reader::getInt64() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::getInt64() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setInt64( ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), value); -} -inline void DomainArray::Builder::setInt64(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::initInt64(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>::Reader +DomainArray::Reader::getInt64() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>::Builder +DomainArray::Builder::getInt64() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setInt64( + ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + value); +} +inline void DomainArray::Builder::setInt64( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>::Builder +DomainArray::Builder::initInt64(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + size); } inline void DomainArray::Builder::adoptInt64( - ::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>::adopt( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>> DomainArray::Builder::disownInt64() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>> +DomainArray::Builder::disownInt64() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::int64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasUint64() const { - return !_reader.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) + .isNull(); } inline bool DomainArray::Builder::hasUint64() { - return !_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader DomainArray::Reader::getUint64() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::getUint64() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setUint64( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), value); -} -inline void DomainArray::Builder::setUint64(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder DomainArray::Builder::initUint64(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +DomainArray::Reader::getUint64() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +DomainArray::Builder::getUint64() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setUint64( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + value); +} +inline void DomainArray::Builder::setUint64( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +DomainArray::Builder::initUint64(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + size); } inline void DomainArray::Builder::adoptUint64( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> DomainArray::Builder::disownUint64() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +DomainArray::Builder::disownUint64() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasFloat32() const { - return !_reader.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) + .isNull(); } inline bool DomainArray::Builder::hasFloat32() { - return !_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List::Reader DomainArray::Reader::getFloat32() const { - return ::capnp::_::PointerHelpers< ::capnp::List>::get(_reader.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS)); -} -inline ::capnp::List::Builder DomainArray::Builder::getFloat32() { - return ::capnp::_::PointerHelpers< ::capnp::List>::get(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setFloat32( ::capnp::List::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), value); -} -inline void DomainArray::Builder::setFloat32(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), value); -} -inline ::capnp::List::Builder DomainArray::Builder::initFloat32(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List>::init(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List::Reader +DomainArray::Reader::getFloat32() const { + return ::capnp::_:: + PointerHelpers<::capnp::List>::get( + _reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline ::capnp::List::Builder +DomainArray::Builder::getFloat32() { + return ::capnp::_:: + PointerHelpers<::capnp::List>::get( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setFloat32( + ::capnp::List::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List>:: + set(_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + value); +} +inline void DomainArray::Builder::setFloat32( + ::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers<::capnp::List>:: + set(_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List::Builder +DomainArray::Builder::initFloat32(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List>::init( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + size); } inline void DomainArray::Builder::adoptFloat32( - ::capnp::Orphan< ::capnp::List>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List>::adopt(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List>&& value) { + ::capnp::_::PointerHelpers<::capnp::List>:: + adopt( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List> DomainArray::Builder::disownFloat32() { - return ::capnp::_::PointerHelpers< ::capnp::List>::disown(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List> +DomainArray::Builder::disownFloat32() { + return ::capnp::_:: + PointerHelpers<::capnp::List>::disown( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); } inline bool DomainArray::Reader::hasFloat64() const { - return !_reader.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) + .isNull(); } inline bool DomainArray::Builder::hasFloat64() { - return !_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List::Reader DomainArray::Reader::getFloat64() const { - return ::capnp::_::PointerHelpers< ::capnp::List>::get(_reader.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS)); -} -inline ::capnp::List::Builder DomainArray::Builder::getFloat64() { - return ::capnp::_::PointerHelpers< ::capnp::List>::get(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS)); -} -inline void DomainArray::Builder::setFloat64( ::capnp::List::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS), value); -} -inline void DomainArray::Builder::setFloat64(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List>::set(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS), value); -} -inline ::capnp::List::Builder DomainArray::Builder::initFloat64(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List>::init(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List::Reader +DomainArray::Reader::getFloat64() const { + return ::capnp::_:: + PointerHelpers<::capnp::List>::get( + _reader.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); +} +inline ::capnp::List::Builder +DomainArray::Builder::getFloat64() { + return ::capnp::_:: + PointerHelpers<::capnp::List>::get( + _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); +} +inline void DomainArray::Builder::setFloat64( + ::capnp::List::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List>:: + set(_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), + value); +} +inline void DomainArray::Builder::setFloat64( + ::kj::ArrayPtr value) { + ::capnp::_::PointerHelpers<::capnp::List>:: + set(_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List::Builder +DomainArray::Builder::initFloat64(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List>::init( + _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), + size); } inline void DomainArray::Builder::adoptFloat64( - ::capnp::Orphan< ::capnp::List>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List>::adopt(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List>&& value) { + ::capnp::_::PointerHelpers<::capnp::List>:: + adopt( + _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List> DomainArray::Builder::disownFloat64() { - return ::capnp::_::PointerHelpers< ::capnp::List>::disown(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List> +DomainArray::Builder::disownFloat64() { + return ::capnp::_:: + PointerHelpers<::capnp::List>::disown( + _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); } inline bool KV::Reader::hasKey() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool KV::Builder::hasKey() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader KV::Reader::getKey() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader KV::Reader::getKey() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder KV::Builder::getKey() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder KV::Builder::getKey() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void KV::Builder::setKey( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void KV::Builder::setKey(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder KV::Builder::initKey(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder KV::Builder::initKey(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } -inline void KV::Builder::adoptKey( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +inline void KV::Builder::adoptKey(::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> KV::Builder::disownKey() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> KV::Builder::disownKey() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool KV::Reader::hasValue() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool KV::Builder::hasValue() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader KV::Reader::getValue() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader KV::Reader::getValue() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder KV::Builder::getValue() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder KV::Builder::getValue() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void KV::Builder::setValue( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void KV::Builder::setValue(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder KV::Builder::initValue(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder KV::Builder::initValue(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } -inline void KV::Builder::adoptValue( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +inline void KV::Builder::adoptValue(::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> KV::Builder::disownValue() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> KV::Builder::disownValue() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Config::Reader::hasEntries() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool Config::Builder::hasEntries() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader Config::Reader::getEntries() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder Config::Builder::getEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void Config::Builder::setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder Config::Builder::initEntries(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp:: + List<::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader + Config::Reader::getEntries() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp:: + List<::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder + Config::Builder::getEntries() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void Config::Builder::setEntries(::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp:: + List<::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder + Config::Builder::initEntries(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void Config::Builder::adoptEntries( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>> Config::Builder::disownEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} - -inline ::uint64_t Array::Reader::getEndTimestamp() const { - return _reader.getDataField< ::uint64_t>( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>> +Config::Builder::disownEntries() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} + +inline ::uint64_t Array::Reader::getEndTimestamp() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t Array::Builder::getEndTimestamp() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t Array::Builder::getEndTimestamp() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void Array::Builder::setEndTimestamp( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void Array::Builder::setEndTimestamp(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool Array::Reader::hasQueryType() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool Array::Builder::hasQueryType() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Array::Reader::getQueryType() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Array::Reader::getQueryType() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Array::Builder::getQueryType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Array::Builder::getQueryType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Array::Builder::setQueryType( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void Array::Builder::setQueryType(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Array::Builder::initQueryType(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Array::Builder::initQueryType(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void Array::Builder::adoptQueryType( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Array::Builder::disownQueryType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Array::Builder::disownQueryType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Array::Reader::hasUri() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool Array::Builder::hasUri() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Array::Reader::getUri() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Array::Reader::getUri() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Array::Builder::getUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Array::Builder::getUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void Array::Builder::setUri( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void Array::Builder::setUri(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Array::Builder::initUri(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Array::Builder::initUri(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } -inline void Array::Builder::adoptUri( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); +inline void Array::Builder::adoptUri(::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Array::Builder::disownUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Array::Builder::disownUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::uint64_t Array::Reader::getStartTimestamp() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t Array::Reader::getStartTimestamp() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t Array::Builder::getStartTimestamp() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t Array::Builder::getStartTimestamp() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Array::Builder::setStartTimestamp( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void Array::Builder::setStartTimestamp(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool Array::Reader::hasArraySchemaLatest() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool Array::Builder::hasArraySchemaLatest() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader Array::Reader::getArraySchemaLatest() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader +Array::Reader::getArraySchemaLatest() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder Array::Builder::getArraySchemaLatest() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder +Array::Builder::getArraySchemaLatest() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline Array::Pipeline::getArraySchemaLatest() { - return ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline(_typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline +Array::Pipeline::getArraySchemaLatest() { + return ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline( + _typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void Array::Builder::setArraySchemaLatest( ::tiledb::sm::serialization::capnp::ArraySchema::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void Array::Builder::setArraySchemaLatest( + ::tiledb::sm::serialization::capnp::ArraySchema::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>:: + set(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder Array::Builder::initArraySchemaLatest() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder +Array::Builder::initArraySchemaLatest() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void Array::Builder::adoptArraySchemaLatest( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>:: + adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema> Array::Builder::disownArraySchemaLatest() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema> +Array::Builder::disownArraySchemaLatest() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Array::Reader::hasArraySchemasAll() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool Array::Builder::hasArraySchemasAll() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader Array::Reader::getArraySchemasAll() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder Array::Builder::getArraySchemasAll() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline Array::Pipeline::getArraySchemasAll() { - return ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline(_typeless.getPointerField(3)); -} -#endif // !CAPNP_LITE -inline void Array::Builder::setArraySchemasAll( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder Array::Builder::initArraySchemasAll() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); +} +inline ::tiledb::sm::serialization::capnp:: + Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader + Array::Reader::getArraySchemasAll() const { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + get(_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp:: + Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder + Array::Builder::getArraySchemasAll() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + get(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline +Array::Pipeline::getArraySchemasAll() { + return ::tiledb::sm::serialization::capnp:: + Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>:: + Pipeline(_typeless.getPointerField(3)); +} +#endif // !CAPNP_LITE +inline void Array::Builder::setArraySchemasAll( + ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline ::tiledb::sm::serialization::capnp:: + Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder + Array::Builder::initArraySchemasAll() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + init(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void Array::Builder::adoptArraySchemasAll( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>> Array::Builder::disownArraySchemasAll() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>> +Array::Builder::disownArraySchemasAll() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool Array::Reader::hasNonEmptyDomain() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool Array::Builder::hasNonEmptyDomain() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader Array::Reader::getNonEmptyDomain() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader +Array::Reader::getNonEmptyDomain() const { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: + get(_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder Array::Builder::getNonEmptyDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder +Array::Builder::getNonEmptyDomain() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: + get(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline Array::Pipeline::getNonEmptyDomain() { - return ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline(_typeless.getPointerField(4)); +inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline +Array::Pipeline::getNonEmptyDomain() { + return ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline( + _typeless.getPointerField(4)); } #endif // !CAPNP_LITE -inline void Array::Builder::setNonEmptyDomain( ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); +inline void Array::Builder::setNonEmptyDomain( + ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: + set(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder Array::Builder::initNonEmptyDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder +Array::Builder::initNonEmptyDomain() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: + init(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline void Array::Builder::adoptNonEmptyDomain( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NonEmptyDomainList> Array::Builder::disownNonEmptyDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::NonEmptyDomainList>&& + value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: + adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::NonEmptyDomainList> +Array::Builder::disownNonEmptyDomain() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: + disown( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool Array::Reader::hasArrayMetadata() const { - return !_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } inline bool Array::Builder::hasArrayMetadata() { - return !_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader Array::Reader::getArrayMetadata() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::get(_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader +Array::Reader::getArrayMetadata() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::get( + _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder Array::Builder::getArrayMetadata() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::get(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder +Array::Builder::getArrayMetadata() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::get( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline Array::Pipeline::getArrayMetadata() { - return ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline(_typeless.getPointerField(5)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline +Array::Pipeline::getArrayMetadata() { + return ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline( + _typeless.getPointerField(5)); } #endif // !CAPNP_LITE -inline void Array::Builder::setArrayMetadata( ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::set(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), value); +inline void Array::Builder::setArrayMetadata( + ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::set( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder Array::Builder::initArrayMetadata() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::init(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder +Array::Builder::initArrayMetadata() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::init( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } inline void Array::Builder::adoptArrayMetadata( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::adopt(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata>&& + value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::adopt( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata> Array::Builder::disownArrayMetadata() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::disown(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata> +Array::Builder::disownArrayMetadata() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::disown( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool Array::Reader::hasArrayDirectory() const { - return !_reader.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) + .isNull(); } inline bool Array::Builder::hasArrayDirectory() { - return !_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Reader Array::Reader::getArrayDirectory() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayDirectory>::get(_reader.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Reader +Array::Reader::getArrayDirectory() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayDirectory>::get( + _reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Builder Array::Builder::getArrayDirectory() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayDirectory>::get(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Builder +Array::Builder::getArrayDirectory() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayDirectory>::get( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Pipeline Array::Pipeline::getArrayDirectory() { - return ::tiledb::sm::serialization::capnp::ArrayDirectory::Pipeline(_typeless.getPointerField(6)); +inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Pipeline +Array::Pipeline::getArrayDirectory() { + return ::tiledb::sm::serialization::capnp::ArrayDirectory::Pipeline( + _typeless.getPointerField(6)); } #endif // !CAPNP_LITE -inline void Array::Builder::setArrayDirectory( ::tiledb::sm::serialization::capnp::ArrayDirectory::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayDirectory>::set(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), value); +inline void Array::Builder::setArrayDirectory( + ::tiledb::sm::serialization::capnp::ArrayDirectory::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayDirectory>::set( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Builder Array::Builder::initArrayDirectory() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayDirectory>::init(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayDirectory::Builder +Array::Builder::initArrayDirectory() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayDirectory>::init( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); } inline void Array::Builder::adoptArrayDirectory( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayDirectory>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayDirectory>::adopt(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayDirectory>&& + value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayDirectory>::adopt( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayDirectory> Array::Builder::disownArrayDirectory() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayDirectory>::disown(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayDirectory> +Array::Builder::disownArrayDirectory() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::ArrayDirectory>:: + disown( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); } inline bool Array::Reader::hasFragmentMetadataAll() const { - return !_reader.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) + .isNull(); } inline bool Array::Builder::hasFragmentMetadataAll() { - return !_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>::Reader Array::Reader::getFragmentMetadataAll() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>::Builder Array::Builder::getFragmentMetadataAll() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); -} -inline void Array::Builder::setFragmentMetadataAll( ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>::Builder Array::Builder::initFragmentMetadataAll(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>::Reader +Array::Reader::getFragmentMetadataAll() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<7>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>::Builder +Array::Builder::getFragmentMetadataAll() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<7>() * + ::capnp::POINTERS)); +} +inline void Array::Builder::setFragmentMetadataAll( + ::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>::Builder +Array::Builder::initFragmentMetadataAll(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + size); } inline void Array::Builder::adoptFragmentMetadataAll( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>> Array::Builder::disownFragmentMetadataAll() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentMetadata, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); -} - -inline ::uint64_t Array::Reader::getOpenedAtEndTimestamp() const { - return _reader.getDataField< ::uint64_t>( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>> +Array::Builder::disownFragmentMetadataAll() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentMetadata, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<7>() * + ::capnp::POINTERS)); +} + +inline ::uint64_t Array::Reader::getOpenedAtEndTimestamp() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t Array::Builder::getOpenedAtEndTimestamp() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t Array::Builder::getOpenedAtEndTimestamp() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void Array::Builder::setOpenedAtEndTimestamp( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void Array::Builder::setOpenedAtEndTimestamp(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool ArrayOpen::Reader::hasConfig() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayOpen::Builder::hasConfig() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader ArrayOpen::Reader::getConfig() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader +ArrayOpen::Reader::getConfig() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayOpen::Builder::getConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +ArrayOpen::Builder::getConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline ArrayOpen::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline +ArrayOpen::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void ArrayOpen::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void ArrayOpen::Builder::setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayOpen::Builder::initConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +ArrayOpen::Builder::initConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void ArrayOpen::Builder::adoptConfig( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> ArrayOpen::Builder::disownConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> +ArrayOpen::Builder::disownConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ArrayOpen::Reader::hasQueryType() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayOpen::Builder::hasQueryType() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader ArrayOpen::Reader::getQueryType() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ArrayOpen::Reader::getQueryType() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ArrayOpen::Builder::getQueryType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ArrayOpen::Builder::getQueryType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void ArrayOpen::Builder::setQueryType( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void ArrayOpen::Builder::setQueryType(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder ArrayOpen::Builder::initQueryType(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder ArrayOpen::Builder::initQueryType( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void ArrayOpen::Builder::adoptQueryType( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> ArrayOpen::Builder::disownQueryType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> ArrayOpen::Builder::disownQueryType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasArrayType() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchema::Builder::hasArrayType() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader ArraySchema::Reader::getArrayType() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ArraySchema::Reader::getArrayType() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ArraySchema::Builder::getArrayType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ArraySchema::Builder::getArrayType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void ArraySchema::Builder::setArrayType( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void ArraySchema::Builder::setArrayType(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder ArraySchema::Builder::initArrayType(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder ArraySchema::Builder::initArrayType( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void ArraySchema::Builder::adoptArrayType( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> ArraySchema::Builder::disownArrayType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> ArraySchema::Builder::disownArrayType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasAttributes() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchema::Builder::hasAttributes() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Reader ArraySchema::Reader::getAttributes() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Builder ArraySchema::Builder::getAttributes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void ArraySchema::Builder::setAttributes( ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Builder ArraySchema::Builder::initAttributes(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>::Reader +ArraySchema::Reader::getAttributes() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>::Builder +ArraySchema::Builder::getAttributes() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline void ArraySchema::Builder::setAttributes( + ::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>::Builder +ArraySchema::Builder::initAttributes(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void ArraySchema::Builder::adoptAttributes( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>> ArraySchema::Builder::disownAttributes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} - -inline ::uint64_t ArraySchema::Reader::getCapacity() const { - return _reader.getDataField< ::uint64_t>( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>> +ArraySchema::Builder::disownAttributes() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} + +inline ::uint64_t ArraySchema::Reader::getCapacity() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t ArraySchema::Builder::getCapacity() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t ArraySchema::Builder::getCapacity() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ArraySchema::Builder::setCapacity( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void ArraySchema::Builder::setCapacity(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool ArraySchema::Reader::hasCellOrder() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchema::Builder::hasCellOrder() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader ArraySchema::Reader::getCellOrder() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ArraySchema::Reader::getCellOrder() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ArraySchema::Builder::getCellOrder() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ArraySchema::Builder::getCellOrder() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void ArraySchema::Builder::setCellOrder( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void ArraySchema::Builder::setCellOrder(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder ArraySchema::Builder::initCellOrder(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder ArraySchema::Builder::initCellOrder( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void ArraySchema::Builder::adoptCellOrder( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> ArraySchema::Builder::disownCellOrder() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> ArraySchema::Builder::disownCellOrder() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasCoordsFilterPipeline() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchema::Builder::hasCoordsFilterPipeline() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader ArraySchema::Reader::getCoordsFilterPipeline() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader +ArraySchema::Reader::getCoordsFilterPipeline() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder ArraySchema::Builder::getCoordsFilterPipeline() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder +ArraySchema::Builder::getCoordsFilterPipeline() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline ArraySchema::Pipeline::getCoordsFilterPipeline() { - return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline(_typeless.getPointerField(3)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline +ArraySchema::Pipeline::getCoordsFilterPipeline() { + return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline( + _typeless.getPointerField(3)); } #endif // !CAPNP_LITE -inline void ArraySchema::Builder::setCoordsFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); +inline void ArraySchema::Builder::setCoordsFilterPipeline( + ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder ArraySchema::Builder::initCoordsFilterPipeline() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder +ArraySchema::Builder::initCoordsFilterPipeline() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void ArraySchema::Builder::adoptCoordsFilterPipeline( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& + value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> ArraySchema::Builder::disownCoordsFilterPipeline() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> +ArraySchema::Builder::disownCoordsFilterPipeline() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::FilterPipeline>:: + disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasDomain() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchema::Builder::hasDomain() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Domain::Reader ArraySchema::Reader::getDomain() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Domain>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Domain::Reader +ArraySchema::Reader::getDomain() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Domain>::get( + _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Domain::Builder ArraySchema::Builder::getDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Domain>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Domain::Builder +ArraySchema::Builder::getDomain() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Domain>::get( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Domain::Pipeline ArraySchema::Pipeline::getDomain() { - return ::tiledb::sm::serialization::capnp::Domain::Pipeline(_typeless.getPointerField(4)); +inline ::tiledb::sm::serialization::capnp::Domain::Pipeline +ArraySchema::Pipeline::getDomain() { + return ::tiledb::sm::serialization::capnp::Domain::Pipeline( + _typeless.getPointerField(4)); } #endif // !CAPNP_LITE -inline void ArraySchema::Builder::setDomain( ::tiledb::sm::serialization::capnp::Domain::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Domain>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); +inline void ArraySchema::Builder::setDomain( + ::tiledb::sm::serialization::capnp::Domain::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Domain>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Domain::Builder ArraySchema::Builder::initDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Domain>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Domain::Builder +ArraySchema::Builder::initDomain() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Domain>::init( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline void ArraySchema::Builder::adoptDomain( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Domain>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Domain>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Domain>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Domain>::adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Domain> ArraySchema::Builder::disownDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Domain>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Domain> +ArraySchema::Builder::disownDomain() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Domain>::disown( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasOffsetFilterPipeline() const { - return !_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchema::Builder::hasOffsetFilterPipeline() { - return !_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader ArraySchema::Reader::getOffsetFilterPipeline() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader +ArraySchema::Reader::getOffsetFilterPipeline() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( + _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder ArraySchema::Builder::getOffsetFilterPipeline() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder +ArraySchema::Builder::getOffsetFilterPipeline() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline ArraySchema::Pipeline::getOffsetFilterPipeline() { - return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline(_typeless.getPointerField(5)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline +ArraySchema::Pipeline::getOffsetFilterPipeline() { + return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline( + _typeless.getPointerField(5)); } #endif // !CAPNP_LITE -inline void ArraySchema::Builder::setOffsetFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::set(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), value); +inline void ArraySchema::Builder::setOffsetFilterPipeline( + ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::set( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder ArraySchema::Builder::initOffsetFilterPipeline() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::init(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder +ArraySchema::Builder::initOffsetFilterPipeline() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::init( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } inline void ArraySchema::Builder::adoptOffsetFilterPipeline( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::adopt(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& + value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::adopt( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> ArraySchema::Builder::disownOffsetFilterPipeline() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::disown(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> +ArraySchema::Builder::disownOffsetFilterPipeline() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::FilterPipeline>:: + disown( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasTileOrder() const { - return !_reader.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchema::Builder::hasTileOrder() { - return !_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader ArraySchema::Reader::getTileOrder() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ArraySchema::Reader::getTileOrder() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ArraySchema::Builder::getTileOrder() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ArraySchema::Builder::getTileOrder() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); } -inline void ArraySchema::Builder::setTileOrder( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), value); +inline void ArraySchema::Builder::setTileOrder(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder ArraySchema::Builder::initTileOrder(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder ArraySchema::Builder::initTileOrder( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + size); } inline void ArraySchema::Builder::adoptTileOrder( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> ArraySchema::Builder::disownTileOrder() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> ArraySchema::Builder::disownTileOrder() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasUri() const { - return !_reader.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchema::Builder::hasUri() { - return !_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader ArraySchema::Reader::getUri() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ArraySchema::Reader::getUri() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ArraySchema::Builder::getUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ArraySchema::Builder::getUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); } -inline void ArraySchema::Builder::setUri( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), value); +inline void ArraySchema::Builder::setUri(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder ArraySchema::Builder::initUri(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder ArraySchema::Builder::initUri(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + size); } inline void ArraySchema::Builder::adoptUri( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> ArraySchema::Builder::disownUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> ArraySchema::Builder::disownUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasVersion() const { - return !_reader.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchema::Builder::hasVersion() { - return !_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader ArraySchema::Reader::getVersion() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder ArraySchema::Builder::getVersion() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS)); -} -inline void ArraySchema::Builder::setVersion( ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), value); -} -inline void ArraySchema::Builder::setVersion(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>::Builder ArraySchema::Builder::initVersion(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Reader +ArraySchema::Reader::getVersion() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Builder +ArraySchema::Builder::getVersion() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline void ArraySchema::Builder::setVersion( + ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + value); +} +inline void ArraySchema::Builder::setVersion( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>::Builder +ArraySchema::Builder::initVersion(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + size); } inline void ArraySchema::Builder::adoptVersion( - ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>::adopt( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>> ArraySchema::Builder::disownVersion() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>> +ArraySchema::Builder::disownVersion() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::int32_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::getAllowsDuplicates() const { - return _reader.getDataField( - ::capnp::bounded<64>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<64>() * ::capnp::ELEMENTS); } inline bool ArraySchema::Builder::getAllowsDuplicates() { @@ -13861,458 +18286,653 @@ inline void ArraySchema::Builder::setAllowsDuplicates(bool value) { } inline bool ArraySchema::Reader::hasValidityFilterPipeline() const { - return !_reader.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchema::Builder::hasValidityFilterPipeline() { - return !_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader ArraySchema::Reader::getValidityFilterPipeline() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_reader.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader +ArraySchema::Reader::getValidityFilterPipeline() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( + _reader.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder ArraySchema::Builder::getValidityFilterPipeline() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder +ArraySchema::Builder::getValidityFilterPipeline() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( + _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline ArraySchema::Pipeline::getValidityFilterPipeline() { - return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline(_typeless.getPointerField(9)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline +ArraySchema::Pipeline::getValidityFilterPipeline() { + return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline( + _typeless.getPointerField(9)); } #endif // !CAPNP_LITE -inline void ArraySchema::Builder::setValidityFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::set(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS), value); +inline void ArraySchema::Builder::setValidityFilterPipeline( + ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::set( + _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder ArraySchema::Builder::initValidityFilterPipeline() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::init(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder +ArraySchema::Builder::initValidityFilterPipeline() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::init( + _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); } inline void ArraySchema::Builder::adoptValidityFilterPipeline( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::adopt(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& + value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::adopt( + _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> ArraySchema::Builder::disownValidityFilterPipeline() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::disown(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> +ArraySchema::Builder::disownValidityFilterPipeline() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::FilterPipeline>:: + disown( + _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasName() const { - return !_reader.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchema::Builder::hasName() { - return !_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader ArraySchema::Reader::getName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ArraySchema::Reader::getName() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ArraySchema::Builder::getName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ArraySchema::Builder::getName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); } -inline void ArraySchema::Builder::setName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS), value); +inline void ArraySchema::Builder::setName(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder ArraySchema::Builder::initName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder ArraySchema::Builder::initName( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), + size); } inline void ArraySchema::Builder::adoptName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> ArraySchema::Builder::disownName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> ArraySchema::Builder::disownName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasTimestampRange() const { - return !_reader.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchema::Builder::hasTimestampRange() { - return !_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader ArraySchema::Reader::getTimestampRange() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder ArraySchema::Builder::getTimestampRange() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS)); -} -inline void ArraySchema::Builder::setTimestampRange( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS), value); -} -inline void ArraySchema::Builder::setTimestampRange(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder ArraySchema::Builder::initTimestampRange(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +ArraySchema::Reader::getTimestampRange() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +ArraySchema::Builder::getTimestampRange() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS)); +} +inline void ArraySchema::Builder::setTimestampRange( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), + value); +} +inline void ArraySchema::Builder::setTimestampRange( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +ArraySchema::Builder::initTimestampRange(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), + size); } inline void ArraySchema::Builder::adoptTimestampRange( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> ArraySchema::Builder::disownTimestampRange() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +ArraySchema::Builder::disownTimestampRange() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasDimensionLabels() const { - return !_reader.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchema::Builder::hasDimensionLabels() { - return !_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>::Reader ArraySchema::Reader::getDimensionLabels() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>::Builder ArraySchema::Builder::getDimensionLabels() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS)); -} -inline void ArraySchema::Builder::setDimensionLabels( ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>::Builder ArraySchema::Builder::initDimensionLabels(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>::Reader +ArraySchema::Reader::getDimensionLabels() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<12>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>::Builder +ArraySchema::Builder::getDimensionLabels() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<12>() * + ::capnp::POINTERS)); +} +inline void ArraySchema::Builder::setDimensionLabels( + ::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>::Builder +ArraySchema::Builder::initDimensionLabels(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), + size); } inline void ArraySchema::Builder::adoptDimensionLabels( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>> ArraySchema::Builder::disownDimensionLabels() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::DimensionLabel, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>> +ArraySchema::Builder::disownDimensionLabels() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::DimensionLabel, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<12>() * + ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasEnumerations() const { - return !_reader.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchema::Builder::hasEnumerations() { - return !_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader ArraySchema::Reader::getEnumerations() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder ArraySchema::Builder::getEnumerations() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS)); -} -inline void ArraySchema::Builder::setEnumerations( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder ArraySchema::Builder::initEnumerations(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader +ArraySchema::Reader::getEnumerations() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<13>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder +ArraySchema::Builder::getEnumerations() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<13>() * + ::capnp::POINTERS)); +} +inline void ArraySchema::Builder::setEnumerations( + ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder +ArraySchema::Builder::initEnumerations(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), + size); } inline void ArraySchema::Builder::adoptEnumerations( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> ArraySchema::Builder::disownEnumerations() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>> +ArraySchema::Builder::disownEnumerations() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<13>() * + ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasEnumerationPathMap() const { - return !_reader.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchema::Builder::hasEnumerationPathMap() { - return !_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader ArraySchema::Reader::getEnumerationPathMap() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder ArraySchema::Builder::getEnumerationPathMap() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS)); -} -inline void ArraySchema::Builder::setEnumerationPathMap( ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder ArraySchema::Builder::initEnumerationPathMap(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp:: + List<::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Reader + ArraySchema::Reader::getEnumerationPathMap() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<14>() * + ::capnp::POINTERS)); +} +inline ::capnp:: + List<::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder + ArraySchema::Builder::getEnumerationPathMap() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<14>() * + ::capnp::POINTERS)); +} +inline void ArraySchema::Builder::setEnumerationPathMap( + ::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), + value); +} +inline ::capnp:: + List<::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>::Builder + ArraySchema::Builder::initEnumerationPathMap(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), + size); } inline void ArraySchema::Builder::adoptEnumerationPathMap( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>> ArraySchema::Builder::disownEnumerationPathMap() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::KV, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>> +ArraySchema::Builder::disownEnumerationPathMap() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::KV, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<14>() * + ::capnp::POINTERS)); } inline bool ArraySchema::Reader::hasCurrentDomain() const { - return !_reader.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchema::Builder::hasCurrentDomain() { - return !_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Reader ArraySchema::Reader::getCurrentDomain() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::get(_reader.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Reader +ArraySchema::Reader::getCurrentDomain() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::get( + _reader.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder ArraySchema::Builder::getCurrentDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::get(_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder +ArraySchema::Builder::getCurrentDomain() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::get( + _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline ArraySchema::Pipeline::getCurrentDomain() { - return ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline(_typeless.getPointerField(15)); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline +ArraySchema::Pipeline::getCurrentDomain() { + return ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline( + _typeless.getPointerField(15)); } #endif // !CAPNP_LITE -inline void ArraySchema::Builder::setCurrentDomain( ::tiledb::sm::serialization::capnp::CurrentDomain::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::set(_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS), value); +inline void ArraySchema::Builder::setCurrentDomain( + ::tiledb::sm::serialization::capnp::CurrentDomain::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::set( + _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder ArraySchema::Builder::initCurrentDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::init(_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder +ArraySchema::Builder::initCurrentDomain() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::init( + _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS)); } inline void ArraySchema::Builder::adoptCurrentDomain( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::CurrentDomain>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::adopt(_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::CurrentDomain> ArraySchema::Builder::disownCurrentDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::disown(_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS)); -} - -inline ::uint32_t DimensionLabel::Reader::getDimensionId() const { - return _reader.getDataField< ::uint32_t>( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::CurrentDomain>&& + value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::adopt( + _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::CurrentDomain> +ArraySchema::Builder::disownCurrentDomain() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::disown( + _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS)); +} + +inline ::uint32_t DimensionLabel::Reader::getDimensionId() const { + return _reader.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint32_t DimensionLabel::Builder::getDimensionId() { - return _builder.getDataField< ::uint32_t>( +inline ::uint32_t DimensionLabel::Builder::getDimensionId() { + return _builder.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void DimensionLabel::Builder::setDimensionId( ::uint32_t value) { - _builder.setDataField< ::uint32_t>( +inline void DimensionLabel::Builder::setDimensionId(::uint32_t value) { + _builder.setDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool DimensionLabel::Reader::hasName() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool DimensionLabel::Builder::hasName() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader DimensionLabel::Reader::getName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader DimensionLabel::Reader::getName() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder DimensionLabel::Builder::getName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder DimensionLabel::Builder::getName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void DimensionLabel::Builder::setName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void DimensionLabel::Builder::setName(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder DimensionLabel::Builder::initName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder DimensionLabel::Builder::initName( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void DimensionLabel::Builder::adoptName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> DimensionLabel::Builder::disownName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> DimensionLabel::Builder::disownName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool DimensionLabel::Reader::hasUri() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool DimensionLabel::Builder::hasUri() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader DimensionLabel::Reader::getUri() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader DimensionLabel::Reader::getUri() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder DimensionLabel::Builder::getUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder DimensionLabel::Builder::getUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void DimensionLabel::Builder::setUri( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void DimensionLabel::Builder::setUri(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder DimensionLabel::Builder::initUri(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder DimensionLabel::Builder::initUri( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void DimensionLabel::Builder::adoptUri( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> DimensionLabel::Builder::disownUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> DimensionLabel::Builder::disownUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool DimensionLabel::Reader::hasAttributeName() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool DimensionLabel::Builder::hasAttributeName() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader DimensionLabel::Reader::getAttributeName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader DimensionLabel::Reader::getAttributeName() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder DimensionLabel::Builder::getAttributeName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder DimensionLabel::Builder::getAttributeName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void DimensionLabel::Builder::setAttributeName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void DimensionLabel::Builder::setAttributeName( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder DimensionLabel::Builder::initAttributeName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder DimensionLabel::Builder::initAttributeName( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void DimensionLabel::Builder::adoptAttributeName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> DimensionLabel::Builder::disownAttributeName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +DimensionLabel::Builder::disownAttributeName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool DimensionLabel::Reader::hasOrder() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool DimensionLabel::Builder::hasOrder() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader DimensionLabel::Reader::getOrder() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader DimensionLabel::Reader::getOrder() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder DimensionLabel::Builder::getOrder() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder DimensionLabel::Builder::getOrder() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline void DimensionLabel::Builder::setOrder( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); +inline void DimensionLabel::Builder::setOrder(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder DimensionLabel::Builder::initOrder(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder DimensionLabel::Builder::initOrder( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + size); } inline void DimensionLabel::Builder::adoptOrder( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> DimensionLabel::Builder::disownOrder() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> DimensionLabel::Builder::disownOrder() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool DimensionLabel::Reader::hasType() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool DimensionLabel::Builder::hasType() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader DimensionLabel::Reader::getType() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader DimensionLabel::Reader::getType() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder DimensionLabel::Builder::getType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder DimensionLabel::Builder::getType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline void DimensionLabel::Builder::setType( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); +inline void DimensionLabel::Builder::setType(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder DimensionLabel::Builder::initType(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder DimensionLabel::Builder::initType( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + size); } inline void DimensionLabel::Builder::adoptType( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> DimensionLabel::Builder::disownType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> DimensionLabel::Builder::disownType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::uint32_t DimensionLabel::Reader::getCellValNum() const { - return _reader.getDataField< ::uint32_t>( +inline ::uint32_t DimensionLabel::Reader::getCellValNum() const { + return _reader.getDataField<::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint32_t DimensionLabel::Builder::getCellValNum() { - return _builder.getDataField< ::uint32_t>( +inline ::uint32_t DimensionLabel::Builder::getCellValNum() { + return _builder.getDataField<::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void DimensionLabel::Builder::setCellValNum( ::uint32_t value) { - _builder.setDataField< ::uint32_t>( +inline void DimensionLabel::Builder::setCellValNum(::uint32_t value) { + _builder.setDataField<::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool DimensionLabel::Reader::getExternal() const { - return _reader.getDataField( - ::capnp::bounded<64>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<64>() * ::capnp::ELEMENTS); } inline bool DimensionLabel::Builder::getExternal() { @@ -14325,8 +18945,7 @@ inline void DimensionLabel::Builder::setExternal(bool value) { } inline bool DimensionLabel::Reader::getRelative() const { - return _reader.getDataField( - ::capnp::bounded<65>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<65>() * ::capnp::ELEMENTS); } inline bool DimensionLabel::Builder::getRelative() { @@ -14339,457 +18958,689 @@ inline void DimensionLabel::Builder::setRelative(bool value) { } inline bool DimensionLabel::Reader::hasSchema() const { - return !_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } inline bool DimensionLabel::Builder::hasSchema() { - return !_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader DimensionLabel::Reader::getSchema() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::get(_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader +DimensionLabel::Reader::getSchema() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::get( + _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder DimensionLabel::Builder::getSchema() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::get(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder +DimensionLabel::Builder::getSchema() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::get( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline DimensionLabel::Pipeline::getSchema() { - return ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline(_typeless.getPointerField(5)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline +DimensionLabel::Pipeline::getSchema() { + return ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline( + _typeless.getPointerField(5)); } #endif // !CAPNP_LITE -inline void DimensionLabel::Builder::setSchema( ::tiledb::sm::serialization::capnp::ArraySchema::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::set(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), value); +inline void DimensionLabel::Builder::setSchema( + ::tiledb::sm::serialization::capnp::ArraySchema::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>:: + set(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder DimensionLabel::Builder::initSchema() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::init(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder +DimensionLabel::Builder::initSchema() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::init( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } inline void DimensionLabel::Builder::adoptSchema( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::adopt(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>:: + adopt( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema> DimensionLabel::Builder::disownSchema() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::disown(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema> +DimensionLabel::Builder::disownSchema() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::disown( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool ArraySchemaEvolution::Reader::hasAttributesToDrop() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchemaEvolution::Builder::hasAttributesToDrop() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArraySchemaEvolution::Reader::getAttributesToDrop() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArraySchemaEvolution::Builder::getAttributesToDrop() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void ArraySchemaEvolution::Builder::setAttributesToDrop( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline void ArraySchemaEvolution::Builder::setAttributesToDrop(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArraySchemaEvolution::Builder::initAttributesToDrop(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +ArraySchemaEvolution::Reader::getAttributesToDrop() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArraySchemaEvolution::Builder::getAttributesToDrop() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void ArraySchemaEvolution::Builder::setAttributesToDrop( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline void ArraySchemaEvolution::Builder::setAttributesToDrop( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArraySchemaEvolution::Builder::initAttributesToDrop(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void ArraySchemaEvolution::Builder::adoptAttributesToDrop( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArraySchemaEvolution::Builder::disownAttributesToDrop() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +ArraySchemaEvolution::Builder::disownAttributesToDrop() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ArraySchemaEvolution::Reader::hasAttributesToAdd() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchemaEvolution::Builder::hasAttributesToAdd() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Reader ArraySchemaEvolution::Reader::getAttributesToAdd() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Builder ArraySchemaEvolution::Builder::getAttributesToAdd() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void ArraySchemaEvolution::Builder::setAttributesToAdd( ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>::Builder ArraySchemaEvolution::Builder::initAttributesToAdd(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>::Reader +ArraySchemaEvolution::Reader::getAttributesToAdd() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>::Builder +ArraySchemaEvolution::Builder::getAttributesToAdd() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline void ArraySchemaEvolution::Builder::setAttributesToAdd( + ::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>::Builder +ArraySchemaEvolution::Builder::initAttributesToAdd(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void ArraySchemaEvolution::Builder::adoptAttributesToAdd( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>> ArraySchemaEvolution::Builder::disownAttributesToAdd() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Attribute, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>> +ArraySchemaEvolution::Builder::disownAttributesToAdd() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Attribute, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); } inline bool ArraySchemaEvolution::Reader::hasTimestampRange() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchemaEvolution::Builder::hasTimestampRange() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader ArraySchemaEvolution::Reader::getTimestampRange() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder ArraySchemaEvolution::Builder::getTimestampRange() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void ArraySchemaEvolution::Builder::setTimestampRange( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline void ArraySchemaEvolution::Builder::setTimestampRange(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder ArraySchemaEvolution::Builder::initTimestampRange(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +ArraySchemaEvolution::Reader::getTimestampRange() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +ArraySchemaEvolution::Builder::getTimestampRange() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void ArraySchemaEvolution::Builder::setTimestampRange( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline void ArraySchemaEvolution::Builder::setTimestampRange( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +ArraySchemaEvolution::Builder::initTimestampRange(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void ArraySchemaEvolution::Builder::adoptTimestampRange( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> ArraySchemaEvolution::Builder::disownTimestampRange() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +ArraySchemaEvolution::Builder::disownTimestampRange() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool ArraySchemaEvolution::Reader::hasEnumerationsToAdd() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchemaEvolution::Builder::hasEnumerationsToAdd() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader ArraySchemaEvolution::Reader::getEnumerationsToAdd() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder ArraySchemaEvolution::Builder::getEnumerationsToAdd() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline void ArraySchemaEvolution::Builder::setEnumerationsToAdd( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder ArraySchemaEvolution::Builder::initEnumerationsToAdd(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader +ArraySchemaEvolution::Reader::getEnumerationsToAdd() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<3>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder +ArraySchemaEvolution::Builder::getEnumerationsToAdd() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<3>() * + ::capnp::POINTERS)); +} +inline void ArraySchemaEvolution::Builder::setEnumerationsToAdd( + ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder +ArraySchemaEvolution::Builder::initEnumerationsToAdd(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + size); } inline void ArraySchemaEvolution::Builder::adoptEnumerationsToAdd( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> ArraySchemaEvolution::Builder::disownEnumerationsToAdd() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>> +ArraySchemaEvolution::Builder::disownEnumerationsToAdd() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<3>() * + ::capnp::POINTERS)); } inline bool ArraySchemaEvolution::Reader::hasEnumerationsToDrop() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchemaEvolution::Builder::hasEnumerationsToDrop() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArraySchemaEvolution::Reader::getEnumerationsToDrop() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArraySchemaEvolution::Builder::getEnumerationsToDrop() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline void ArraySchemaEvolution::Builder::setEnumerationsToDrop( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); -} -inline void ArraySchemaEvolution::Builder::setEnumerationsToDrop(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArraySchemaEvolution::Builder::initEnumerationsToDrop(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +ArraySchemaEvolution::Reader::getEnumerationsToDrop() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArraySchemaEvolution::Builder::getEnumerationsToDrop() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void ArraySchemaEvolution::Builder::setEnumerationsToDrop( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); +} +inline void ArraySchemaEvolution::Builder::setEnumerationsToDrop( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArraySchemaEvolution::Builder::initEnumerationsToDrop(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + size); } inline void ArraySchemaEvolution::Builder::adoptEnumerationsToDrop( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArraySchemaEvolution::Builder::disownEnumerationsToDrop() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +ArraySchemaEvolution::Builder::disownEnumerationsToDrop() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool ArraySchemaEvolution::Reader::hasEnumerationsToExtend() const { - return !_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchemaEvolution::Builder::hasEnumerationsToExtend() { - return !_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader ArraySchemaEvolution::Reader::getEnumerationsToExtend() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder ArraySchemaEvolution::Builder::getEnumerationsToExtend() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline void ArraySchemaEvolution::Builder::setEnumerationsToExtend( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder ArraySchemaEvolution::Builder::initEnumerationsToExtend(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader +ArraySchemaEvolution::Reader::getEnumerationsToExtend() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<5>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder +ArraySchemaEvolution::Builder::getEnumerationsToExtend() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<5>() * + ::capnp::POINTERS)); +} +inline void ArraySchemaEvolution::Builder::setEnumerationsToExtend( + ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder +ArraySchemaEvolution::Builder::initEnumerationsToExtend(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + size); } inline void ArraySchemaEvolution::Builder::adoptEnumerationsToExtend( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> ArraySchemaEvolution::Builder::disownEnumerationsToExtend() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>> +ArraySchemaEvolution::Builder::disownEnumerationsToExtend() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<5>() * + ::capnp::POINTERS)); } inline bool ArraySchemaEvolution::Reader::hasCurrentDomainToExpand() const { - return !_reader.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) + .isNull(); } inline bool ArraySchemaEvolution::Builder::hasCurrentDomainToExpand() { - return !_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Reader ArraySchemaEvolution::Reader::getCurrentDomainToExpand() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::get(_reader.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Reader +ArraySchemaEvolution::Reader::getCurrentDomainToExpand() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::get( + _reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder ArraySchemaEvolution::Builder::getCurrentDomainToExpand() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::get(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder +ArraySchemaEvolution::Builder::getCurrentDomainToExpand() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::get( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline ArraySchemaEvolution::Pipeline::getCurrentDomainToExpand() { - return ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline(_typeless.getPointerField(6)); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline +ArraySchemaEvolution::Pipeline::getCurrentDomainToExpand() { + return ::tiledb::sm::serialization::capnp::CurrentDomain::Pipeline( + _typeless.getPointerField(6)); } #endif // !CAPNP_LITE -inline void ArraySchemaEvolution::Builder::setCurrentDomainToExpand( ::tiledb::sm::serialization::capnp::CurrentDomain::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::set(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), value); +inline void ArraySchemaEvolution::Builder::setCurrentDomainToExpand( + ::tiledb::sm::serialization::capnp::CurrentDomain::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::set( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder ArraySchemaEvolution::Builder::initCurrentDomainToExpand() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::init(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Builder +ArraySchemaEvolution::Builder::initCurrentDomainToExpand() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::init( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); } inline void ArraySchemaEvolution::Builder::adoptCurrentDomainToExpand( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::CurrentDomain>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::adopt(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::CurrentDomain> ArraySchemaEvolution::Builder::disownCurrentDomainToExpand() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::CurrentDomain>::disown(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); -} - -inline ::uint32_t Attribute::Reader::getCellValNum() const { - return _reader.getDataField< ::uint32_t>( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::CurrentDomain>&& + value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::adopt( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::CurrentDomain> +ArraySchemaEvolution::Builder::disownCurrentDomainToExpand() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::CurrentDomain>::disown( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +} + +inline ::uint32_t Attribute::Reader::getCellValNum() const { + return _reader.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint32_t Attribute::Builder::getCellValNum() { - return _builder.getDataField< ::uint32_t>( +inline ::uint32_t Attribute::Builder::getCellValNum() { + return _builder.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void Attribute::Builder::setCellValNum( ::uint32_t value) { - _builder.setDataField< ::uint32_t>( +inline void Attribute::Builder::setCellValNum(::uint32_t value) { + _builder.setDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool Attribute::Reader::hasName() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool Attribute::Builder::hasName() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Attribute::Reader::getName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Attribute::Reader::getName() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Attribute::Builder::getName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Attribute::Builder::getName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Attribute::Builder::setName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void Attribute::Builder::setName(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Attribute::Builder::initName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Attribute::Builder::initName(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void Attribute::Builder::adoptName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Attribute::Builder::disownName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Attribute::Builder::disownName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Attribute::Reader::hasType() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool Attribute::Builder::hasType() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Attribute::Reader::getType() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Attribute::Reader::getType() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Attribute::Builder::getType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Attribute::Builder::getType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void Attribute::Builder::setType( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void Attribute::Builder::setType(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Attribute::Builder::initType(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Attribute::Builder::initType(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void Attribute::Builder::adoptType( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Attribute::Builder::disownType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Attribute::Builder::disownType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Attribute::Reader::hasFilterPipeline() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool Attribute::Builder::hasFilterPipeline() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader Attribute::Reader::getFilterPipeline() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader +Attribute::Reader::getFilterPipeline() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder Attribute::Builder::getFilterPipeline() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder +Attribute::Builder::getFilterPipeline() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline Attribute::Pipeline::getFilterPipeline() { - return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline(_typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline +Attribute::Pipeline::getFilterPipeline() { + return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline( + _typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void Attribute::Builder::setFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void Attribute::Builder::setFilterPipeline( + ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder Attribute::Builder::initFilterPipeline() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder +Attribute::Builder::initFilterPipeline() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void Attribute::Builder::adoptFilterPipeline( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& + value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> Attribute::Builder::disownFilterPipeline() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> +Attribute::Builder::disownFilterPipeline() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::FilterPipeline>:: + disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Attribute::Reader::hasFillValue() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool Attribute::Builder::hasFillValue() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Data::Reader Attribute::Reader::getFillValue() const { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Data::Reader Attribute::Reader::getFillValue() const { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::capnp::Data::Builder Attribute::Builder::getFillValue() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Data::Builder Attribute::Builder::getFillValue() { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline void Attribute::Builder::setFillValue( ::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); +inline void Attribute::Builder::setFillValue(::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Data>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); } -inline ::capnp::Data::Builder Attribute::Builder::initFillValue(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), size); +inline ::capnp::Data::Builder Attribute::Builder::initFillValue( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Data>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + size); } inline void Attribute::Builder::adoptFillValue( - ::capnp::Orphan< ::capnp::Data>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Data>&& value) { + ::capnp::_::PointerHelpers<::capnp::Data>::adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Data> Attribute::Builder::disownFillValue() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Data> Attribute::Builder::disownFillValue() { + return ::capnp::_::PointerHelpers<::capnp::Data>::disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool Attribute::Reader::getNullable() const { - return _reader.getDataField( - ::capnp::bounded<32>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<32>() * ::capnp::ELEMENTS); } inline bool Attribute::Builder::getNullable() { @@ -14802,8 +19653,7 @@ inline void Attribute::Builder::setNullable(bool value) { } inline bool Attribute::Reader::getFillValueValidity() const { - return _reader.getDataField( - ::capnp::bounded<33>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<33>() * ::capnp::ELEMENTS); } inline bool Attribute::Builder::getFillValueValidity() { @@ -14816,192 +19666,212 @@ inline void Attribute::Builder::setFillValueValidity(bool value) { } inline bool Attribute::Reader::hasOrder() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool Attribute::Builder::hasOrder() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Attribute::Reader::getOrder() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Attribute::Reader::getOrder() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Attribute::Builder::getOrder() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Attribute::Builder::getOrder() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline void Attribute::Builder::setOrder( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); +inline void Attribute::Builder::setOrder(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Attribute::Builder::initOrder(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Attribute::Builder::initOrder(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + size); } inline void Attribute::Builder::adoptOrder( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Attribute::Builder::disownOrder() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Attribute::Builder::disownOrder() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool Attribute::Reader::hasEnumerationName() const { - return !_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } inline bool Attribute::Builder::hasEnumerationName() { - return !_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Attribute::Reader::getEnumerationName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Attribute::Reader::getEnumerationName() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Attribute::Builder::getEnumerationName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Attribute::Builder::getEnumerationName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline void Attribute::Builder::setEnumerationName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), value); +inline void Attribute::Builder::setEnumerationName( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Attribute::Builder::initEnumerationName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Attribute::Builder::initEnumerationName( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + size); } inline void Attribute::Builder::adoptEnumerationName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Attribute::Builder::disownEnumerationName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +Attribute::Builder::disownEnumerationName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool Enumeration::Reader::hasName() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool Enumeration::Builder::hasName() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Enumeration::Reader::getName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Enumeration::Reader::getName() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Enumeration::Builder::getName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Enumeration::Builder::getName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Enumeration::Builder::setName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void Enumeration::Builder::setName(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Enumeration::Builder::initName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Enumeration::Builder::initName( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void Enumeration::Builder::adoptName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Enumeration::Builder::disownName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Enumeration::Builder::disownName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Enumeration::Reader::hasPathName() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool Enumeration::Builder::hasPathName() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Enumeration::Reader::getPathName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Enumeration::Reader::getPathName() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Enumeration::Builder::getPathName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Enumeration::Builder::getPathName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void Enumeration::Builder::setPathName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void Enumeration::Builder::setPathName(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Enumeration::Builder::initPathName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Enumeration::Builder::initPathName( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void Enumeration::Builder::adoptPathName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Enumeration::Builder::disownPathName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Enumeration::Builder::disownPathName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Enumeration::Reader::hasType() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool Enumeration::Builder::hasType() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Enumeration::Reader::getType() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Enumeration::Reader::getType() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Enumeration::Builder::getType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Enumeration::Builder::getType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void Enumeration::Builder::setType( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void Enumeration::Builder::setType(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Enumeration::Builder::initType(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Enumeration::Builder::initType( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void Enumeration::Builder::adoptType( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Enumeration::Builder::disownType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Enumeration::Builder::disownType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::uint32_t Enumeration::Reader::getCellValNum() const { - return _reader.getDataField< ::uint32_t>( +inline ::uint32_t Enumeration::Reader::getCellValNum() const { + return _reader.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint32_t Enumeration::Builder::getCellValNum() { - return _builder.getDataField< ::uint32_t>( +inline ::uint32_t Enumeration::Builder::getCellValNum() { + return _builder.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void Enumeration::Builder::setCellValNum( ::uint32_t value) { - _builder.setDataField< ::uint32_t>( +inline void Enumeration::Builder::setCellValNum(::uint32_t value) { + _builder.setDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool Enumeration::Reader::getOrdered() const { - return _reader.getDataField( - ::capnp::bounded<32>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<32>() * ::capnp::ELEMENTS); } inline bool Enumeration::Builder::getOrdered() { @@ -15014,374 +19884,450 @@ inline void Enumeration::Builder::setOrdered(bool value) { } inline bool Enumeration::Reader::hasData() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool Enumeration::Builder::hasData() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Data::Reader Enumeration::Reader::getData() const { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Data::Reader Enumeration::Reader::getData() const { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::capnp::Data::Builder Enumeration::Builder::getData() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Data::Builder Enumeration::Builder::getData() { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline void Enumeration::Builder::setData( ::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); +inline void Enumeration::Builder::setData(::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Data>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); } -inline ::capnp::Data::Builder Enumeration::Builder::initData(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), size); +inline ::capnp::Data::Builder Enumeration::Builder::initData( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Data>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + size); } inline void Enumeration::Builder::adoptData( - ::capnp::Orphan< ::capnp::Data>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Data>&& value) { + ::capnp::_::PointerHelpers<::capnp::Data>::adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Data> Enumeration::Builder::disownData() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Data> Enumeration::Builder::disownData() { + return ::capnp::_::PointerHelpers<::capnp::Data>::disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool Enumeration::Reader::hasOffsets() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool Enumeration::Builder::hasOffsets() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Data::Reader Enumeration::Reader::getOffsets() const { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Data::Reader Enumeration::Reader::getOffsets() const { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::capnp::Data::Builder Enumeration::Builder::getOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Data::Builder Enumeration::Builder::getOffsets() { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline void Enumeration::Builder::setOffsets( ::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); +inline void Enumeration::Builder::setOffsets(::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Data>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); } -inline ::capnp::Data::Builder Enumeration::Builder::initOffsets(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), size); +inline ::capnp::Data::Builder Enumeration::Builder::initOffsets( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Data>::init( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + size); } inline void Enumeration::Builder::adoptOffsets( - ::capnp::Orphan< ::capnp::Data>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Data>&& value) { + ::capnp::_::PointerHelpers<::capnp::Data>::adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Data> Enumeration::Builder::disownOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Data> Enumeration::Builder::disownOffsets() { + return ::capnp::_::PointerHelpers<::capnp::Data>::disown( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool AttributeBufferHeader::Reader::hasName() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool AttributeBufferHeader::Builder::hasName() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader AttributeBufferHeader::Reader::getName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader AttributeBufferHeader::Reader::getName() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder AttributeBufferHeader::Builder::getName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder AttributeBufferHeader::Builder::getName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void AttributeBufferHeader::Builder::setName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void AttributeBufferHeader::Builder::setName( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder AttributeBufferHeader::Builder::initName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder AttributeBufferHeader::Builder::initName( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void AttributeBufferHeader::Builder::adoptName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> AttributeBufferHeader::Builder::disownName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +AttributeBufferHeader::Builder::disownName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t AttributeBufferHeader::Reader::getFixedLenBufferSizeInBytes() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t AttributeBufferHeader::Reader::getFixedLenBufferSizeInBytes() + const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t AttributeBufferHeader::Builder::getFixedLenBufferSizeInBytes() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t +AttributeBufferHeader::Builder::getFixedLenBufferSizeInBytes() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void AttributeBufferHeader::Builder::setFixedLenBufferSizeInBytes( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void AttributeBufferHeader::Builder::setFixedLenBufferSizeInBytes( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t AttributeBufferHeader::Reader::getVarLenBufferSizeInBytes() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t AttributeBufferHeader::Reader::getVarLenBufferSizeInBytes() + const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t AttributeBufferHeader::Builder::getVarLenBufferSizeInBytes() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t AttributeBufferHeader::Builder::getVarLenBufferSizeInBytes() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void AttributeBufferHeader::Builder::setVarLenBufferSizeInBytes( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void AttributeBufferHeader::Builder::setVarLenBufferSizeInBytes( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t AttributeBufferHeader::Reader::getValidityLenBufferSizeInBytes() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t +AttributeBufferHeader::Reader::getValidityLenBufferSizeInBytes() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t AttributeBufferHeader::Builder::getValidityLenBufferSizeInBytes() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t +AttributeBufferHeader::Builder::getValidityLenBufferSizeInBytes() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void AttributeBufferHeader::Builder::setValidityLenBufferSizeInBytes( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void AttributeBufferHeader::Builder::setValidityLenBufferSizeInBytes( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t AttributeBufferHeader::Reader::getOriginalFixedLenBufferSizeInBytes() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t +AttributeBufferHeader::Reader::getOriginalFixedLenBufferSizeInBytes() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS); } -inline ::uint64_t AttributeBufferHeader::Builder::getOriginalFixedLenBufferSizeInBytes() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t +AttributeBufferHeader::Builder::getOriginalFixedLenBufferSizeInBytes() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS); } -inline void AttributeBufferHeader::Builder::setOriginalFixedLenBufferSizeInBytes( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void +AttributeBufferHeader::Builder::setOriginalFixedLenBufferSizeInBytes( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t AttributeBufferHeader::Reader::getOriginalVarLenBufferSizeInBytes() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t +AttributeBufferHeader::Reader::getOriginalVarLenBufferSizeInBytes() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS); } -inline ::uint64_t AttributeBufferHeader::Builder::getOriginalVarLenBufferSizeInBytes() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t +AttributeBufferHeader::Builder::getOriginalVarLenBufferSizeInBytes() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS); } -inline void AttributeBufferHeader::Builder::setOriginalVarLenBufferSizeInBytes( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void AttributeBufferHeader::Builder::setOriginalVarLenBufferSizeInBytes( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t AttributeBufferHeader::Reader::getOriginalValidityLenBufferSizeInBytes() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t +AttributeBufferHeader::Reader::getOriginalValidityLenBufferSizeInBytes() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<5>() * ::capnp::ELEMENTS); } -inline ::uint64_t AttributeBufferHeader::Builder::getOriginalValidityLenBufferSizeInBytes() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t +AttributeBufferHeader::Builder::getOriginalValidityLenBufferSizeInBytes() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<5>() * ::capnp::ELEMENTS); } -inline void AttributeBufferHeader::Builder::setOriginalValidityLenBufferSizeInBytes( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void +AttributeBufferHeader::Builder::setOriginalValidityLenBufferSizeInBytes( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<5>() * ::capnp::ELEMENTS, value); } inline bool Dimension::Reader::hasName() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool Dimension::Builder::hasName() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Dimension::Reader::getName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Dimension::Reader::getName() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Dimension::Builder::getName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Dimension::Builder::getName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Dimension::Builder::setName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void Dimension::Builder::setName(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Dimension::Builder::initName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Dimension::Builder::initName(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void Dimension::Builder::adoptName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Dimension::Builder::disownName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Dimension::Builder::disownName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Dimension::Reader::getNullTileExtent() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool Dimension::Builder::getNullTileExtent() { - return _builder.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void Dimension::Builder::setNullTileExtent(bool value) { - _builder.setDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool Dimension::Reader::hasType() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool Dimension::Builder::hasType() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Dimension::Reader::getType() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Dimension::Reader::getType() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Dimension::Builder::getType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Dimension::Builder::getType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void Dimension::Builder::setType( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void Dimension::Builder::setType(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Dimension::Builder::initType(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Dimension::Builder::initType(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void Dimension::Builder::adoptType( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Dimension::Builder::disownType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Dimension::Builder::disownType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline typename Dimension::TileExtent::Reader Dimension::Reader::getTileExtent() const { +inline typename Dimension::TileExtent::Reader Dimension::Reader::getTileExtent() + const { return typename Dimension::TileExtent::Reader(_reader); } -inline typename Dimension::TileExtent::Builder Dimension::Builder::getTileExtent() { +inline typename Dimension::TileExtent::Builder +Dimension::Builder::getTileExtent() { return typename Dimension::TileExtent::Builder(_builder); } #if !CAPNP_LITE -inline typename Dimension::TileExtent::Pipeline Dimension::Pipeline::getTileExtent() { +inline typename Dimension::TileExtent::Pipeline +Dimension::Pipeline::getTileExtent() { return typename Dimension::TileExtent::Pipeline(_typeless.noop()); } #endif // !CAPNP_LITE -inline typename Dimension::TileExtent::Builder Dimension::Builder::initTileExtent() { - _builder.setDataField< ::uint8_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); - _builder.setDataField< ::uint16_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); - _builder.setDataField< ::uint32_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); - _builder.setDataField< ::uint64_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); +inline typename Dimension::TileExtent::Builder +Dimension::Builder::initTileExtent() { + _builder.setDataField<::uint8_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.setDataField<::uint16_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.setDataField<::uint32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.setDataField<::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); return typename Dimension::TileExtent::Builder(_builder); } inline bool Dimension::Reader::hasDomain() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool Dimension::Builder::hasDomain() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Reader Dimension::Reader::getDomain() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Reader +Dimension::Reader::getDomain() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Builder Dimension::Builder::getDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Builder +Dimension::Builder::getDomain() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline Dimension::Pipeline::getDomain() { - return ::tiledb::sm::serialization::capnp::DomainArray::Pipeline(_typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline +Dimension::Pipeline::getDomain() { + return ::tiledb::sm::serialization::capnp::DomainArray::Pipeline( + _typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void Dimension::Builder::setDomain( ::tiledb::sm::serialization::capnp::DomainArray::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void Dimension::Builder::setDomain( + ::tiledb::sm::serialization::capnp::DomainArray::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>:: + set(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Builder Dimension::Builder::initDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Builder +Dimension::Builder::initDomain() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void Dimension::Builder::adoptDomain( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>:: + adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray> Dimension::Builder::disownDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray> +Dimension::Builder::disownDomain() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Dimension::Reader::hasFilterPipeline() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool Dimension::Builder::hasFilterPipeline() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader Dimension::Reader::getFilterPipeline() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Reader +Dimension::Reader::getFilterPipeline() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder Dimension::Builder::getFilterPipeline() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder +Dimension::Builder::getFilterPipeline() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline Dimension::Pipeline::getFilterPipeline() { - return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline(_typeless.getPointerField(3)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline +Dimension::Pipeline::getFilterPipeline() { + return ::tiledb::sm::serialization::capnp::FilterPipeline::Pipeline( + _typeless.getPointerField(3)); } #endif // !CAPNP_LITE -inline void Dimension::Builder::setFilterPipeline( ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); +inline void Dimension::Builder::setFilterPipeline( + ::tiledb::sm::serialization::capnp::FilterPipeline::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder Dimension::Builder::initFilterPipeline() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FilterPipeline::Builder +Dimension::Builder::initFilterPipeline() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void Dimension::Builder::adoptFilterPipeline( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FilterPipeline> Dimension::Builder::disownFilterPipeline() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FilterPipeline>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} - -inline ::tiledb::sm::serialization::capnp::Dimension::TileExtent::Which Dimension::TileExtent::Reader::which() const { - return _reader.getDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS); -} -inline ::tiledb::sm::serialization::capnp::Dimension::TileExtent::Which Dimension::TileExtent::Builder::which() { + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline>&& + value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FilterPipeline>::adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FilterPipeline> +Dimension::Builder::disownFilterPipeline() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::FilterPipeline>:: + disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline ::tiledb::sm::serialization::capnp::Dimension::TileExtent::Which +Dimension::TileExtent::Reader::which() const { + return _reader.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline ::tiledb::sm::serialization::capnp::Dimension::TileExtent::Which +Dimension::TileExtent::Builder::which() { return _builder.getDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } @@ -15392,23 +20338,25 @@ inline bool Dimension::TileExtent::Reader::isInt8() const { inline bool Dimension::TileExtent::Builder::isInt8() { return which() == Dimension::TileExtent::INT8; } -inline ::int8_t Dimension::TileExtent::Reader::getInt8() const { - KJ_IREQUIRE((which() == Dimension::TileExtent::INT8), - "Must check which() before get()ing a union member."); - return _reader.getDataField< ::int8_t>( +inline ::int8_t Dimension::TileExtent::Reader::getInt8() const { + KJ_IREQUIRE( + (which() == Dimension::TileExtent::INT8), + "Must check which() before get()ing a union member."); + return _reader.getDataField<::int8_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::int8_t Dimension::TileExtent::Builder::getInt8() { - KJ_IREQUIRE((which() == Dimension::TileExtent::INT8), - "Must check which() before get()ing a union member."); - return _builder.getDataField< ::int8_t>( +inline ::int8_t Dimension::TileExtent::Builder::getInt8() { + KJ_IREQUIRE( + (which() == Dimension::TileExtent::INT8), + "Must check which() before get()ing a union member."); + return _builder.getDataField<::int8_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Dimension::TileExtent::Builder::setInt8( ::int8_t value) { +inline void Dimension::TileExtent::Builder::setInt8(::int8_t value) { _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::INT8); - _builder.setDataField< ::int8_t>( + _builder.setDataField<::int8_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -15418,23 +20366,25 @@ inline bool Dimension::TileExtent::Reader::isUint8() const { inline bool Dimension::TileExtent::Builder::isUint8() { return which() == Dimension::TileExtent::UINT8; } -inline ::uint8_t Dimension::TileExtent::Reader::getUint8() const { - KJ_IREQUIRE((which() == Dimension::TileExtent::UINT8), - "Must check which() before get()ing a union member."); - return _reader.getDataField< ::uint8_t>( +inline ::uint8_t Dimension::TileExtent::Reader::getUint8() const { + KJ_IREQUIRE( + (which() == Dimension::TileExtent::UINT8), + "Must check which() before get()ing a union member."); + return _reader.getDataField<::uint8_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint8_t Dimension::TileExtent::Builder::getUint8() { - KJ_IREQUIRE((which() == Dimension::TileExtent::UINT8), - "Must check which() before get()ing a union member."); - return _builder.getDataField< ::uint8_t>( +inline ::uint8_t Dimension::TileExtent::Builder::getUint8() { + KJ_IREQUIRE( + (which() == Dimension::TileExtent::UINT8), + "Must check which() before get()ing a union member."); + return _builder.getDataField<::uint8_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Dimension::TileExtent::Builder::setUint8( ::uint8_t value) { +inline void Dimension::TileExtent::Builder::setUint8(::uint8_t value) { _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::UINT8); - _builder.setDataField< ::uint8_t>( + _builder.setDataField<::uint8_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -15444,23 +20394,25 @@ inline bool Dimension::TileExtent::Reader::isInt16() const { inline bool Dimension::TileExtent::Builder::isInt16() { return which() == Dimension::TileExtent::INT16; } -inline ::int16_t Dimension::TileExtent::Reader::getInt16() const { - KJ_IREQUIRE((which() == Dimension::TileExtent::INT16), - "Must check which() before get()ing a union member."); - return _reader.getDataField< ::int16_t>( +inline ::int16_t Dimension::TileExtent::Reader::getInt16() const { + KJ_IREQUIRE( + (which() == Dimension::TileExtent::INT16), + "Must check which() before get()ing a union member."); + return _reader.getDataField<::int16_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::int16_t Dimension::TileExtent::Builder::getInt16() { - KJ_IREQUIRE((which() == Dimension::TileExtent::INT16), - "Must check which() before get()ing a union member."); - return _builder.getDataField< ::int16_t>( +inline ::int16_t Dimension::TileExtent::Builder::getInt16() { + KJ_IREQUIRE( + (which() == Dimension::TileExtent::INT16), + "Must check which() before get()ing a union member."); + return _builder.getDataField<::int16_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void Dimension::TileExtent::Builder::setInt16( ::int16_t value) { +inline void Dimension::TileExtent::Builder::setInt16(::int16_t value) { _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::INT16); - _builder.setDataField< ::int16_t>( + _builder.setDataField<::int16_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } @@ -15470,23 +20422,25 @@ inline bool Dimension::TileExtent::Reader::isUint16() const { inline bool Dimension::TileExtent::Builder::isUint16() { return which() == Dimension::TileExtent::UINT16; } -inline ::uint16_t Dimension::TileExtent::Reader::getUint16() const { - KJ_IREQUIRE((which() == Dimension::TileExtent::UINT16), - "Must check which() before get()ing a union member."); - return _reader.getDataField< ::uint16_t>( +inline ::uint16_t Dimension::TileExtent::Reader::getUint16() const { + KJ_IREQUIRE( + (which() == Dimension::TileExtent::UINT16), + "Must check which() before get()ing a union member."); + return _reader.getDataField<::uint16_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint16_t Dimension::TileExtent::Builder::getUint16() { - KJ_IREQUIRE((which() == Dimension::TileExtent::UINT16), - "Must check which() before get()ing a union member."); - return _builder.getDataField< ::uint16_t>( +inline ::uint16_t Dimension::TileExtent::Builder::getUint16() { + KJ_IREQUIRE( + (which() == Dimension::TileExtent::UINT16), + "Must check which() before get()ing a union member."); + return _builder.getDataField<::uint16_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void Dimension::TileExtent::Builder::setUint16( ::uint16_t value) { +inline void Dimension::TileExtent::Builder::setUint16(::uint16_t value) { _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::UINT16); - _builder.setDataField< ::uint16_t>( + _builder.setDataField<::uint16_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } @@ -15496,23 +20450,25 @@ inline bool Dimension::TileExtent::Reader::isInt32() const { inline bool Dimension::TileExtent::Builder::isInt32() { return which() == Dimension::TileExtent::INT32; } -inline ::int32_t Dimension::TileExtent::Reader::getInt32() const { - KJ_IREQUIRE((which() == Dimension::TileExtent::INT32), - "Must check which() before get()ing a union member."); - return _reader.getDataField< ::int32_t>( +inline ::int32_t Dimension::TileExtent::Reader::getInt32() const { + KJ_IREQUIRE( + (which() == Dimension::TileExtent::INT32), + "Must check which() before get()ing a union member."); + return _reader.getDataField<::int32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::int32_t Dimension::TileExtent::Builder::getInt32() { - KJ_IREQUIRE((which() == Dimension::TileExtent::INT32), - "Must check which() before get()ing a union member."); - return _builder.getDataField< ::int32_t>( +inline ::int32_t Dimension::TileExtent::Builder::getInt32() { + KJ_IREQUIRE( + (which() == Dimension::TileExtent::INT32), + "Must check which() before get()ing a union member."); + return _builder.getDataField<::int32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Dimension::TileExtent::Builder::setInt32( ::int32_t value) { +inline void Dimension::TileExtent::Builder::setInt32(::int32_t value) { _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::INT32); - _builder.setDataField< ::int32_t>( + _builder.setDataField<::int32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -15522,23 +20478,25 @@ inline bool Dimension::TileExtent::Reader::isUint32() const { inline bool Dimension::TileExtent::Builder::isUint32() { return which() == Dimension::TileExtent::UINT32; } -inline ::uint32_t Dimension::TileExtent::Reader::getUint32() const { - KJ_IREQUIRE((which() == Dimension::TileExtent::UINT32), - "Must check which() before get()ing a union member."); - return _reader.getDataField< ::uint32_t>( +inline ::uint32_t Dimension::TileExtent::Reader::getUint32() const { + KJ_IREQUIRE( + (which() == Dimension::TileExtent::UINT32), + "Must check which() before get()ing a union member."); + return _reader.getDataField<::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint32_t Dimension::TileExtent::Builder::getUint32() { - KJ_IREQUIRE((which() == Dimension::TileExtent::UINT32), - "Must check which() before get()ing a union member."); - return _builder.getDataField< ::uint32_t>( +inline ::uint32_t Dimension::TileExtent::Builder::getUint32() { + KJ_IREQUIRE( + (which() == Dimension::TileExtent::UINT32), + "Must check which() before get()ing a union member."); + return _builder.getDataField<::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Dimension::TileExtent::Builder::setUint32( ::uint32_t value) { +inline void Dimension::TileExtent::Builder::setUint32(::uint32_t value) { _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::UINT32); - _builder.setDataField< ::uint32_t>( + _builder.setDataField<::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -15548,23 +20506,25 @@ inline bool Dimension::TileExtent::Reader::isInt64() const { inline bool Dimension::TileExtent::Builder::isInt64() { return which() == Dimension::TileExtent::INT64; } -inline ::int64_t Dimension::TileExtent::Reader::getInt64() const { - KJ_IREQUIRE((which() == Dimension::TileExtent::INT64), - "Must check which() before get()ing a union member."); - return _reader.getDataField< ::int64_t>( +inline ::int64_t Dimension::TileExtent::Reader::getInt64() const { + KJ_IREQUIRE( + (which() == Dimension::TileExtent::INT64), + "Must check which() before get()ing a union member."); + return _reader.getDataField<::int64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::int64_t Dimension::TileExtent::Builder::getInt64() { - KJ_IREQUIRE((which() == Dimension::TileExtent::INT64), - "Must check which() before get()ing a union member."); - return _builder.getDataField< ::int64_t>( +inline ::int64_t Dimension::TileExtent::Builder::getInt64() { + KJ_IREQUIRE( + (which() == Dimension::TileExtent::INT64), + "Must check which() before get()ing a union member."); + return _builder.getDataField<::int64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Dimension::TileExtent::Builder::setInt64( ::int64_t value) { +inline void Dimension::TileExtent::Builder::setInt64(::int64_t value) { _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::INT64); - _builder.setDataField< ::int64_t>( + _builder.setDataField<::int64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -15574,23 +20534,25 @@ inline bool Dimension::TileExtent::Reader::isUint64() const { inline bool Dimension::TileExtent::Builder::isUint64() { return which() == Dimension::TileExtent::UINT64; } -inline ::uint64_t Dimension::TileExtent::Reader::getUint64() const { - KJ_IREQUIRE((which() == Dimension::TileExtent::UINT64), - "Must check which() before get()ing a union member."); - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t Dimension::TileExtent::Reader::getUint64() const { + KJ_IREQUIRE( + (which() == Dimension::TileExtent::UINT64), + "Must check which() before get()ing a union member."); + return _reader.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t Dimension::TileExtent::Builder::getUint64() { - KJ_IREQUIRE((which() == Dimension::TileExtent::UINT64), - "Must check which() before get()ing a union member."); - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t Dimension::TileExtent::Builder::getUint64() { + KJ_IREQUIRE( + (which() == Dimension::TileExtent::UINT64), + "Must check which() before get()ing a union member."); + return _builder.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Dimension::TileExtent::Builder::setUint64( ::uint64_t value) { +inline void Dimension::TileExtent::Builder::setUint64(::uint64_t value) { _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::UINT64); - _builder.setDataField< ::uint64_t>( + _builder.setDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -15601,21 +20563,23 @@ inline bool Dimension::TileExtent::Builder::isFloat32() { return which() == Dimension::TileExtent::FLOAT32; } inline float Dimension::TileExtent::Reader::getFloat32() const { - KJ_IREQUIRE((which() == Dimension::TileExtent::FLOAT32), - "Must check which() before get()ing a union member."); - return _reader.getDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS); + KJ_IREQUIRE( + (which() == Dimension::TileExtent::FLOAT32), + "Must check which() before get()ing a union member."); + return _reader.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline float Dimension::TileExtent::Builder::getFloat32() { - KJ_IREQUIRE((which() == Dimension::TileExtent::FLOAT32), - "Must check which() before get()ing a union member."); + KJ_IREQUIRE( + (which() == Dimension::TileExtent::FLOAT32), + "Must check which() before get()ing a union member."); return _builder.getDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline void Dimension::TileExtent::Builder::setFloat32(float value) { _builder.setDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::FLOAT32); + ::capnp::bounded<1>() * ::capnp::ELEMENTS, + Dimension::TileExtent::FLOAT32); _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -15627,207 +20591,263 @@ inline bool Dimension::TileExtent::Builder::isFloat64() { return which() == Dimension::TileExtent::FLOAT64; } inline double Dimension::TileExtent::Reader::getFloat64() const { - KJ_IREQUIRE((which() == Dimension::TileExtent::FLOAT64), - "Must check which() before get()ing a union member."); + KJ_IREQUIRE( + (which() == Dimension::TileExtent::FLOAT64), + "Must check which() before get()ing a union member."); return _reader.getDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline double Dimension::TileExtent::Builder::getFloat64() { - KJ_IREQUIRE((which() == Dimension::TileExtent::FLOAT64), - "Must check which() before get()ing a union member."); + KJ_IREQUIRE( + (which() == Dimension::TileExtent::FLOAT64), + "Must check which() before get()ing a union member."); return _builder.getDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline void Dimension::TileExtent::Builder::setFloat64(double value) { _builder.setDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS, Dimension::TileExtent::FLOAT64); + ::capnp::bounded<1>() * ::capnp::ELEMENTS, + Dimension::TileExtent::FLOAT64); _builder.setDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool Domain::Reader::hasCellOrder() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool Domain::Builder::hasCellOrder() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Domain::Reader::getCellOrder() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Domain::Reader::getCellOrder() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Domain::Builder::getCellOrder() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Domain::Builder::getCellOrder() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Domain::Builder::setCellOrder( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void Domain::Builder::setCellOrder(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Domain::Builder::initCellOrder(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Domain::Builder::initCellOrder( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void Domain::Builder::adoptCellOrder( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Domain::Builder::disownCellOrder() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Domain::Builder::disownCellOrder() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Domain::Reader::hasDimensions() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool Domain::Builder::hasDimensions() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>::Reader Domain::Reader::getDimensions() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>::Builder Domain::Builder::getDimensions() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void Domain::Builder::setDimensions( ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>::Builder Domain::Builder::initDimensions(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>::Reader +Domain::Reader::getDimensions() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>::Builder +Domain::Builder::getDimensions() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline void Domain::Builder::setDimensions( + ::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>::Builder +Domain::Builder::initDimensions(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void Domain::Builder::adoptDimensions( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>> Domain::Builder::disownDimensions() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Dimension, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>> +Domain::Builder::disownDimensions() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Dimension, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); } inline bool Domain::Reader::hasTileOrder() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool Domain::Builder::hasTileOrder() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Domain::Reader::getTileOrder() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Domain::Reader::getTileOrder() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Domain::Builder::getTileOrder() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Domain::Builder::getTileOrder() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void Domain::Builder::setTileOrder( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void Domain::Builder::setTileOrder(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Domain::Builder::initTileOrder(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Domain::Builder::initTileOrder( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void Domain::Builder::adoptTileOrder( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Domain::Builder::disownTileOrder() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Domain::Builder::disownTileOrder() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Domain::Reader::hasType() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool Domain::Builder::hasType() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Domain::Reader::getType() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Domain::Reader::getType() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Domain::Builder::getType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Domain::Builder::getType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline void Domain::Builder::setType( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); +inline void Domain::Builder::setType(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Domain::Builder::initType(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Domain::Builder::initType(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + size); } -inline void Domain::Builder::adoptType( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +inline void Domain::Builder::adoptType(::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Domain::Builder::disownType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Domain::Builder::disownType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::int64_t Error::Reader::getCode() const { - return _reader.getDataField< ::int64_t>( +inline ::int64_t Error::Reader::getCode() const { + return _reader.getDataField<::int64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::int64_t Error::Builder::getCode() { - return _builder.getDataField< ::int64_t>( +inline ::int64_t Error::Builder::getCode() { + return _builder.getDataField<::int64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void Error::Builder::setCode( ::int64_t value) { - _builder.setDataField< ::int64_t>( +inline void Error::Builder::setCode(::int64_t value) { + _builder.setDataField<::int64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool Error::Reader::hasMessage() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool Error::Builder::hasMessage() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Error::Reader::getMessage() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Error::Reader::getMessage() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Error::Builder::getMessage() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Error::Builder::getMessage() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Error::Builder::setMessage( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void Error::Builder::setMessage(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Error::Builder::initMessage(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Error::Builder::initMessage(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void Error::Builder::adoptMessage( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Error::Builder::disownMessage() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Error::Builder::disownMessage() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline double FloatScaleConfig::Reader::getScale() const { @@ -15858,23 +20878,22 @@ inline void FloatScaleConfig::Builder::setOffset(double value) { ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t FloatScaleConfig::Reader::getByteWidth() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t FloatScaleConfig::Reader::getByteWidth() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t FloatScaleConfig::Builder::getByteWidth() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t FloatScaleConfig::Builder::getByteWidth() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void FloatScaleConfig::Builder::setByteWidth( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void FloatScaleConfig::Builder::setByteWidth(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline float WebpConfig::Reader::getQuality() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline float WebpConfig::Builder::getQuality() { @@ -15886,23 +20905,22 @@ inline void WebpConfig::Builder::setQuality(float value) { ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint8_t WebpConfig::Reader::getFormat() const { - return _reader.getDataField< ::uint8_t>( +inline ::uint8_t WebpConfig::Reader::getFormat() const { + return _reader.getDataField<::uint8_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS); } -inline ::uint8_t WebpConfig::Builder::getFormat() { - return _builder.getDataField< ::uint8_t>( +inline ::uint8_t WebpConfig::Builder::getFormat() { + return _builder.getDataField<::uint8_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS); } -inline void WebpConfig::Builder::setFormat( ::uint8_t value) { - _builder.setDataField< ::uint8_t>( +inline void WebpConfig::Builder::setFormat(::uint8_t value) { + _builder.setDataField<::uint8_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS, value); } inline bool WebpConfig::Reader::getLossless() const { - return _reader.getDataField( - ::capnp::bounded<40>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<40>() * ::capnp::ELEMENTS); } inline bool WebpConfig::Builder::getLossless() { @@ -15914,66 +20932,68 @@ inline void WebpConfig::Builder::setLossless(bool value) { ::capnp::bounded<40>() * ::capnp::ELEMENTS, value); } -inline ::uint16_t WebpConfig::Reader::getExtentX() const { - return _reader.getDataField< ::uint16_t>( +inline ::uint16_t WebpConfig::Reader::getExtentX() const { + return _reader.getDataField<::uint16_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS); } -inline ::uint16_t WebpConfig::Builder::getExtentX() { - return _builder.getDataField< ::uint16_t>( +inline ::uint16_t WebpConfig::Builder::getExtentX() { + return _builder.getDataField<::uint16_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS); } -inline void WebpConfig::Builder::setExtentX( ::uint16_t value) { - _builder.setDataField< ::uint16_t>( +inline void WebpConfig::Builder::setExtentX(::uint16_t value) { + _builder.setDataField<::uint16_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS, value); } -inline ::uint16_t WebpConfig::Reader::getExtentY() const { - return _reader.getDataField< ::uint16_t>( +inline ::uint16_t WebpConfig::Reader::getExtentY() const { + return _reader.getDataField<::uint16_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS); } -inline ::uint16_t WebpConfig::Builder::getExtentY() { - return _builder.getDataField< ::uint16_t>( +inline ::uint16_t WebpConfig::Builder::getExtentY() { + return _builder.getDataField<::uint16_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS); } -inline void WebpConfig::Builder::setExtentY( ::uint16_t value) { - _builder.setDataField< ::uint16_t>( +inline void WebpConfig::Builder::setExtentY(::uint16_t value) { + _builder.setDataField<::uint16_t>( ::capnp::bounded<4>() * ::capnp::ELEMENTS, value); } inline bool Filter::Reader::hasType() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool Filter::Builder::hasType() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Filter::Reader::getType() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Filter::Reader::getType() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Filter::Builder::getType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Filter::Builder::getType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Filter::Builder::setType( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void Filter::Builder::setType(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Filter::Builder::initType(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Filter::Builder::initType(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } -inline void Filter::Builder::adoptType( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); +inline void Filter::Builder::adoptType(::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Filter::Builder::disownType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Filter::Builder::disownType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline typename Filter::Data::Reader Filter::Reader::getData() const { @@ -15988,96 +21008,133 @@ inline typename Filter::Data::Pipeline Filter::Pipeline::getData() { } #endif // !CAPNP_LITE inline typename Filter::Data::Builder Filter::Builder::initData() { - _builder.setDataField< ::uint16_t>(::capnp::bounded<0>() * ::capnp::ELEMENTS, 0); - _builder.setDataField< ::uint16_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); - _builder.setDataField< ::uint32_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); - _builder.setDataField< ::uint64_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.setDataField<::uint16_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, 0); + _builder.setDataField<::uint16_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.setDataField<::uint32_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); + _builder.setDataField<::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, 0); _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS).clear(); return typename Filter::Data::Builder(_builder); } inline bool Filter::Reader::hasFloatScaleConfig() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool Filter::Builder::hasFloatScaleConfig() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Reader Filter::Reader::getFloatScaleConfig() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FloatScaleConfig>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Reader +Filter::Reader::getFloatScaleConfig() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FloatScaleConfig>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Builder Filter::Builder::getFloatScaleConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FloatScaleConfig>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Builder +Filter::Builder::getFloatScaleConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FloatScaleConfig>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Pipeline Filter::Pipeline::getFloatScaleConfig() { - return ::tiledb::sm::serialization::capnp::FloatScaleConfig::Pipeline(_typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Pipeline +Filter::Pipeline::getFloatScaleConfig() { + return ::tiledb::sm::serialization::capnp::FloatScaleConfig::Pipeline( + _typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void Filter::Builder::setFloatScaleConfig( ::tiledb::sm::serialization::capnp::FloatScaleConfig::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FloatScaleConfig>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void Filter::Builder::setFloatScaleConfig( + ::tiledb::sm::serialization::capnp::FloatScaleConfig::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FloatScaleConfig>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Builder Filter::Builder::initFloatScaleConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FloatScaleConfig>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FloatScaleConfig::Builder +Filter::Builder::initFloatScaleConfig() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::FloatScaleConfig>:: + init(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void Filter::Builder::adoptFloatScaleConfig( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FloatScaleConfig>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FloatScaleConfig>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FloatScaleConfig> Filter::Builder::disownFloatScaleConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FloatScaleConfig>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FloatScaleConfig>&& + value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::FloatScaleConfig>:: + adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FloatScaleConfig> +Filter::Builder::disownFloatScaleConfig() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::FloatScaleConfig>:: + disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Filter::Reader::hasWebpConfig() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool Filter::Builder::hasWebpConfig() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::WebpConfig::Reader Filter::Reader::getWebpConfig() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::WebpConfig>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::WebpConfig::Reader +Filter::Reader::getWebpConfig() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::WebpConfig>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::WebpConfig::Builder Filter::Builder::getWebpConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::WebpConfig>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::WebpConfig::Builder +Filter::Builder::getWebpConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::WebpConfig>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::WebpConfig::Pipeline Filter::Pipeline::getWebpConfig() { - return ::tiledb::sm::serialization::capnp::WebpConfig::Pipeline(_typeless.getPointerField(3)); +inline ::tiledb::sm::serialization::capnp::WebpConfig::Pipeline +Filter::Pipeline::getWebpConfig() { + return ::tiledb::sm::serialization::capnp::WebpConfig::Pipeline( + _typeless.getPointerField(3)); } #endif // !CAPNP_LITE -inline void Filter::Builder::setWebpConfig( ::tiledb::sm::serialization::capnp::WebpConfig::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::WebpConfig>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); +inline void Filter::Builder::setWebpConfig( + ::tiledb::sm::serialization::capnp::WebpConfig::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::WebpConfig>:: + set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::WebpConfig::Builder Filter::Builder::initWebpConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::WebpConfig>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::WebpConfig::Builder +Filter::Builder::initWebpConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::WebpConfig>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void Filter::Builder::adoptWebpConfig( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::WebpConfig>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::WebpConfig>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::WebpConfig>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::WebpConfig>:: + adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::WebpConfig> Filter::Builder::disownWebpConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::WebpConfig>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::WebpConfig> +Filter::Builder::disownWebpConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::WebpConfig>::disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Filter::Data::Which Filter::Data::Reader::which() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); +inline ::tiledb::sm::serialization::capnp::Filter::Data::Which +Filter::Data::Reader::which() const { + return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::tiledb::sm::serialization::capnp::Filter::Data::Which Filter::Data::Builder::which() { +inline ::tiledb::sm::serialization::capnp::Filter::Data::Which +Filter::Data::Builder::which() { return _builder.getDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } @@ -16089,51 +21146,60 @@ inline bool Filter::Data::Builder::isText() { return which() == Filter::Data::TEXT; } inline bool Filter::Data::Reader::hasText() const { - if (which() != Filter::Data::TEXT) return false; - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + if (which() != Filter::Data::TEXT) + return false; + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool Filter::Data::Builder::hasText() { - if (which() != Filter::Data::TEXT) return false; - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::Text::Reader Filter::Data::Reader::getText() const { - KJ_IREQUIRE((which() == Filter::Data::TEXT), - "Must check which() before get()ing a union member."); - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder Filter::Data::Builder::getText() { - KJ_IREQUIRE((which() == Filter::Data::TEXT), - "Must check which() before get()ing a union member."); - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void Filter::Data::Builder::setText( ::capnp::Text::Reader value) { + if (which() != Filter::Data::TEXT) + return false; + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::Text::Reader Filter::Data::Reader::getText() const { + KJ_IREQUIRE( + (which() == Filter::Data::TEXT), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder Filter::Data::Builder::getText() { + KJ_IREQUIRE( + (which() == Filter::Data::TEXT), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void Filter::Data::Builder::setText(::capnp::Text::Reader value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::TEXT); - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Filter::Data::Builder::initText(unsigned int size) { +inline ::capnp::Text::Builder Filter::Data::Builder::initText( + unsigned int size) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::TEXT); - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void Filter::Data::Builder::adoptText( - ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::Orphan<::capnp::Text>&& value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::TEXT); - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Filter::Data::Builder::disownText() { - KJ_IREQUIRE((which() == Filter::Data::TEXT), - "Must check which() before get()ing a union member."); - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Filter::Data::Builder::disownText() { + KJ_IREQUIRE( + (which() == Filter::Data::TEXT), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Filter::Data::Reader::isBytes() const { @@ -16143,51 +21209,60 @@ inline bool Filter::Data::Builder::isBytes() { return which() == Filter::Data::BYTES; } inline bool Filter::Data::Reader::hasBytes() const { - if (which() != Filter::Data::BYTES) return false; - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + if (which() != Filter::Data::BYTES) + return false; + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool Filter::Data::Builder::hasBytes() { - if (which() != Filter::Data::BYTES) return false; - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::Data::Reader Filter::Data::Reader::getBytes() const { - KJ_IREQUIRE((which() == Filter::Data::BYTES), - "Must check which() before get()ing a union member."); - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::Data::Builder Filter::Data::Builder::getBytes() { - KJ_IREQUIRE((which() == Filter::Data::BYTES), - "Must check which() before get()ing a union member."); - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void Filter::Data::Builder::setBytes( ::capnp::Data::Reader value) { + if (which() != Filter::Data::BYTES) + return false; + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::Data::Reader Filter::Data::Reader::getBytes() const { + KJ_IREQUIRE( + (which() == Filter::Data::BYTES), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Data::Builder Filter::Data::Builder::getBytes() { + KJ_IREQUIRE( + (which() == Filter::Data::BYTES), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void Filter::Data::Builder::setBytes(::capnp::Data::Reader value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::BYTES); - ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); + ::capnp::_::PointerHelpers<::capnp::Data>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::capnp::Data::Builder Filter::Data::Builder::initBytes(unsigned int size) { +inline ::capnp::Data::Builder Filter::Data::Builder::initBytes( + unsigned int size) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::BYTES); - return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return ::capnp::_::PointerHelpers<::capnp::Data>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void Filter::Data::Builder::adoptBytes( - ::capnp::Orphan< ::capnp::Data>&& value) { + ::capnp::Orphan<::capnp::Data>&& value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::BYTES); - ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::_::PointerHelpers<::capnp::Data>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Data> Filter::Data::Builder::disownBytes() { - KJ_IREQUIRE((which() == Filter::Data::BYTES), - "Must check which() before get()ing a union member."); - return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Data> Filter::Data::Builder::disownBytes() { + KJ_IREQUIRE( + (which() == Filter::Data::BYTES), + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers<::capnp::Data>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Filter::Data::Reader::isInt8() const { @@ -16196,23 +21271,25 @@ inline bool Filter::Data::Reader::isInt8() const { inline bool Filter::Data::Builder::isInt8() { return which() == Filter::Data::INT8; } -inline ::int8_t Filter::Data::Reader::getInt8() const { - KJ_IREQUIRE((which() == Filter::Data::INT8), - "Must check which() before get()ing a union member."); - return _reader.getDataField< ::int8_t>( +inline ::int8_t Filter::Data::Reader::getInt8() const { + KJ_IREQUIRE( + (which() == Filter::Data::INT8), + "Must check which() before get()ing a union member."); + return _reader.getDataField<::int8_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::int8_t Filter::Data::Builder::getInt8() { - KJ_IREQUIRE((which() == Filter::Data::INT8), - "Must check which() before get()ing a union member."); - return _builder.getDataField< ::int8_t>( +inline ::int8_t Filter::Data::Builder::getInt8() { + KJ_IREQUIRE( + (which() == Filter::Data::INT8), + "Must check which() before get()ing a union member."); + return _builder.getDataField<::int8_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void Filter::Data::Builder::setInt8( ::int8_t value) { +inline void Filter::Data::Builder::setInt8(::int8_t value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::INT8); - _builder.setDataField< ::int8_t>( + _builder.setDataField<::int8_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } @@ -16222,23 +21299,25 @@ inline bool Filter::Data::Reader::isUint8() const { inline bool Filter::Data::Builder::isUint8() { return which() == Filter::Data::UINT8; } -inline ::uint8_t Filter::Data::Reader::getUint8() const { - KJ_IREQUIRE((which() == Filter::Data::UINT8), - "Must check which() before get()ing a union member."); - return _reader.getDataField< ::uint8_t>( +inline ::uint8_t Filter::Data::Reader::getUint8() const { + KJ_IREQUIRE( + (which() == Filter::Data::UINT8), + "Must check which() before get()ing a union member."); + return _reader.getDataField<::uint8_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint8_t Filter::Data::Builder::getUint8() { - KJ_IREQUIRE((which() == Filter::Data::UINT8), - "Must check which() before get()ing a union member."); - return _builder.getDataField< ::uint8_t>( +inline ::uint8_t Filter::Data::Builder::getUint8() { + KJ_IREQUIRE( + (which() == Filter::Data::UINT8), + "Must check which() before get()ing a union member."); + return _builder.getDataField<::uint8_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void Filter::Data::Builder::setUint8( ::uint8_t value) { +inline void Filter::Data::Builder::setUint8(::uint8_t value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::UINT8); - _builder.setDataField< ::uint8_t>( + _builder.setDataField<::uint8_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } @@ -16248,23 +21327,25 @@ inline bool Filter::Data::Reader::isInt16() const { inline bool Filter::Data::Builder::isInt16() { return which() == Filter::Data::INT16; } -inline ::int16_t Filter::Data::Reader::getInt16() const { - KJ_IREQUIRE((which() == Filter::Data::INT16), - "Must check which() before get()ing a union member."); - return _reader.getDataField< ::int16_t>( +inline ::int16_t Filter::Data::Reader::getInt16() const { + KJ_IREQUIRE( + (which() == Filter::Data::INT16), + "Must check which() before get()ing a union member."); + return _reader.getDataField<::int16_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::int16_t Filter::Data::Builder::getInt16() { - KJ_IREQUIRE((which() == Filter::Data::INT16), - "Must check which() before get()ing a union member."); - return _builder.getDataField< ::int16_t>( +inline ::int16_t Filter::Data::Builder::getInt16() { + KJ_IREQUIRE( + (which() == Filter::Data::INT16), + "Must check which() before get()ing a union member."); + return _builder.getDataField<::int16_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Filter::Data::Builder::setInt16( ::int16_t value) { +inline void Filter::Data::Builder::setInt16(::int16_t value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::INT16); - _builder.setDataField< ::int16_t>( + _builder.setDataField<::int16_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -16274,23 +21355,25 @@ inline bool Filter::Data::Reader::isUint16() const { inline bool Filter::Data::Builder::isUint16() { return which() == Filter::Data::UINT16; } -inline ::uint16_t Filter::Data::Reader::getUint16() const { - KJ_IREQUIRE((which() == Filter::Data::UINT16), - "Must check which() before get()ing a union member."); - return _reader.getDataField< ::uint16_t>( +inline ::uint16_t Filter::Data::Reader::getUint16() const { + KJ_IREQUIRE( + (which() == Filter::Data::UINT16), + "Must check which() before get()ing a union member."); + return _reader.getDataField<::uint16_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint16_t Filter::Data::Builder::getUint16() { - KJ_IREQUIRE((which() == Filter::Data::UINT16), - "Must check which() before get()ing a union member."); - return _builder.getDataField< ::uint16_t>( +inline ::uint16_t Filter::Data::Builder::getUint16() { + KJ_IREQUIRE( + (which() == Filter::Data::UINT16), + "Must check which() before get()ing a union member."); + return _builder.getDataField<::uint16_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Filter::Data::Builder::setUint16( ::uint16_t value) { +inline void Filter::Data::Builder::setUint16(::uint16_t value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::UINT16); - _builder.setDataField< ::uint16_t>( + _builder.setDataField<::uint16_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -16300,23 +21383,25 @@ inline bool Filter::Data::Reader::isInt32() const { inline bool Filter::Data::Builder::isInt32() { return which() == Filter::Data::INT32; } -inline ::int32_t Filter::Data::Reader::getInt32() const { - KJ_IREQUIRE((which() == Filter::Data::INT32), - "Must check which() before get()ing a union member."); - return _reader.getDataField< ::int32_t>( +inline ::int32_t Filter::Data::Reader::getInt32() const { + KJ_IREQUIRE( + (which() == Filter::Data::INT32), + "Must check which() before get()ing a union member."); + return _reader.getDataField<::int32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::int32_t Filter::Data::Builder::getInt32() { - KJ_IREQUIRE((which() == Filter::Data::INT32), - "Must check which() before get()ing a union member."); - return _builder.getDataField< ::int32_t>( +inline ::int32_t Filter::Data::Builder::getInt32() { + KJ_IREQUIRE( + (which() == Filter::Data::INT32), + "Must check which() before get()ing a union member."); + return _builder.getDataField<::int32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Filter::Data::Builder::setInt32( ::int32_t value) { +inline void Filter::Data::Builder::setInt32(::int32_t value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::INT32); - _builder.setDataField< ::int32_t>( + _builder.setDataField<::int32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -16326,23 +21411,25 @@ inline bool Filter::Data::Reader::isUint32() const { inline bool Filter::Data::Builder::isUint32() { return which() == Filter::Data::UINT32; } -inline ::uint32_t Filter::Data::Reader::getUint32() const { - KJ_IREQUIRE((which() == Filter::Data::UINT32), - "Must check which() before get()ing a union member."); - return _reader.getDataField< ::uint32_t>( +inline ::uint32_t Filter::Data::Reader::getUint32() const { + KJ_IREQUIRE( + (which() == Filter::Data::UINT32), + "Must check which() before get()ing a union member."); + return _reader.getDataField<::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint32_t Filter::Data::Builder::getUint32() { - KJ_IREQUIRE((which() == Filter::Data::UINT32), - "Must check which() before get()ing a union member."); - return _builder.getDataField< ::uint32_t>( +inline ::uint32_t Filter::Data::Builder::getUint32() { + KJ_IREQUIRE( + (which() == Filter::Data::UINT32), + "Must check which() before get()ing a union member."); + return _builder.getDataField<::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Filter::Data::Builder::setUint32( ::uint32_t value) { +inline void Filter::Data::Builder::setUint32(::uint32_t value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::UINT32); - _builder.setDataField< ::uint32_t>( + _builder.setDataField<::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -16352,23 +21439,25 @@ inline bool Filter::Data::Reader::isInt64() const { inline bool Filter::Data::Builder::isInt64() { return which() == Filter::Data::INT64; } -inline ::int64_t Filter::Data::Reader::getInt64() const { - KJ_IREQUIRE((which() == Filter::Data::INT64), - "Must check which() before get()ing a union member."); - return _reader.getDataField< ::int64_t>( +inline ::int64_t Filter::Data::Reader::getInt64() const { + KJ_IREQUIRE( + (which() == Filter::Data::INT64), + "Must check which() before get()ing a union member."); + return _reader.getDataField<::int64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::int64_t Filter::Data::Builder::getInt64() { - KJ_IREQUIRE((which() == Filter::Data::INT64), - "Must check which() before get()ing a union member."); - return _builder.getDataField< ::int64_t>( +inline ::int64_t Filter::Data::Builder::getInt64() { + KJ_IREQUIRE( + (which() == Filter::Data::INT64), + "Must check which() before get()ing a union member."); + return _builder.getDataField<::int64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Filter::Data::Builder::setInt64( ::int64_t value) { +inline void Filter::Data::Builder::setInt64(::int64_t value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::INT64); - _builder.setDataField< ::int64_t>( + _builder.setDataField<::int64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -16378,23 +21467,25 @@ inline bool Filter::Data::Reader::isUint64() const { inline bool Filter::Data::Builder::isUint64() { return which() == Filter::Data::UINT64; } -inline ::uint64_t Filter::Data::Reader::getUint64() const { - KJ_IREQUIRE((which() == Filter::Data::UINT64), - "Must check which() before get()ing a union member."); - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t Filter::Data::Reader::getUint64() const { + KJ_IREQUIRE( + (which() == Filter::Data::UINT64), + "Must check which() before get()ing a union member."); + return _reader.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t Filter::Data::Builder::getUint64() { - KJ_IREQUIRE((which() == Filter::Data::UINT64), - "Must check which() before get()ing a union member."); - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t Filter::Data::Builder::getUint64() { + KJ_IREQUIRE( + (which() == Filter::Data::UINT64), + "Must check which() before get()ing a union member."); + return _builder.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Filter::Data::Builder::setUint64( ::uint64_t value) { +inline void Filter::Data::Builder::setUint64(::uint64_t value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, Filter::Data::UINT64); - _builder.setDataField< ::uint64_t>( + _builder.setDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } @@ -16405,15 +21496,16 @@ inline bool Filter::Data::Builder::isFloat32() { return which() == Filter::Data::FLOAT32; } inline float Filter::Data::Reader::getFloat32() const { - KJ_IREQUIRE((which() == Filter::Data::FLOAT32), - "Must check which() before get()ing a union member."); - return _reader.getDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS); + KJ_IREQUIRE( + (which() == Filter::Data::FLOAT32), + "Must check which() before get()ing a union member."); + return _reader.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline float Filter::Data::Builder::getFloat32() { - KJ_IREQUIRE((which() == Filter::Data::FLOAT32), - "Must check which() before get()ing a union member."); + KJ_IREQUIRE( + (which() == Filter::Data::FLOAT32), + "Must check which() before get()ing a union member."); return _builder.getDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } @@ -16431,15 +21523,17 @@ inline bool Filter::Data::Builder::isFloat64() { return which() == Filter::Data::FLOAT64; } inline double Filter::Data::Reader::getFloat64() const { - KJ_IREQUIRE((which() == Filter::Data::FLOAT64), - "Must check which() before get()ing a union member."); + KJ_IREQUIRE( + (which() == Filter::Data::FLOAT64), + "Must check which() before get()ing a union member."); return _reader.getDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline double Filter::Data::Builder::getFloat64() { - KJ_IREQUIRE((which() == Filter::Data::FLOAT64), - "Must check which() before get()ing a union member."); + KJ_IREQUIRE( + (which() == Filter::Data::FLOAT64), + "Must check which() before get()ing a union member."); return _builder.getDataField( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } @@ -16451,185 +21545,277 @@ inline void Filter::Data::Builder::setFloat64(double value) { } inline bool FilterPipeline::Reader::hasFilters() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool FilterPipeline::Builder::hasFilters() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>::Reader FilterPipeline::Reader::getFilters() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>::Builder FilterPipeline::Builder::getFilters() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void FilterPipeline::Builder::setFilters( ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>::Builder FilterPipeline::Builder::initFilters(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>::Reader +FilterPipeline::Reader::getFilters() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>::Builder +FilterPipeline::Builder::getFilters() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void FilterPipeline::Builder::setFilters( + ::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>::Builder +FilterPipeline::Builder::initFilters(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void FilterPipeline::Builder::adoptFilters( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>> FilterPipeline::Builder::disownFilters() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Filter, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>> +FilterPipeline::Builder::disownFilters() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Filter, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } template inline bool Map::Reader::hasEntries() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } template inline bool Map::Builder::hasEntries() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } template -inline typename ::capnp::List::Entry, ::capnp::Kind::STRUCT>::Reader Map::Reader::getEntries() const { - return ::capnp::_::PointerHelpers< ::capnp::List::Entry, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline typename ::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>::Reader +Map::Reader::getEntries() const { + return ::capnp::_::PointerHelpers<::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } template -inline typename ::capnp::List::Entry, ::capnp::Kind::STRUCT>::Builder Map::Builder::getEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List::Entry, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline typename ::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>::Builder +Map::Builder::getEntries() { + return ::capnp::_::PointerHelpers<::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } template -inline void Map::Builder::setEntries(typename ::capnp::List::Entry, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List::Entry, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void Map::Builder::setEntries( + typename ::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } template -inline typename ::capnp::List::Entry, ::capnp::Kind::STRUCT>::Builder Map::Builder::initEntries(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List::Entry, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline typename ::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>::Builder +Map::Builder::initEntries(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } template inline void Map::Builder::adoptEntries( - ::capnp::Orphan< ::capnp::List::Entry, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List::Entry, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } template -inline ::capnp::Orphan< ::capnp::List::Entry, ::capnp::Kind::STRUCT>> Map::Builder::disownEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List::Entry, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>> +Map::Builder::disownEntries() { + return ::capnp::_::PointerHelpers<::capnp::List< + typename ::tiledb::sm::serialization::capnp::Map::Entry, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } template inline bool Map::Entry::Reader::hasKey() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } template inline bool Map::Entry::Builder::hasKey() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } template -inline ::capnp::ReaderFor Map::Entry::Reader::getKey() const { - return ::capnp::_::PointerHelpers::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::ReaderFor Map::Entry::Reader::getKey() const { + return ::capnp::_::PointerHelpers::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } template -inline ::capnp::BuilderFor Map::Entry::Builder::getKey() { - return ::capnp::_::PointerHelpers::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::BuilderFor Map::Entry::Builder::getKey() { + return ::capnp::_::PointerHelpers::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE template -inline ::capnp::PipelineFor Map::Entry::Pipeline::getKey() { - return ::capnp::PipelineFor(_typeless.getPointerField(0)); +inline ::capnp::PipelineFor Map::Entry::Pipeline::getKey() { + return ::capnp::PipelineFor(_typeless.getPointerField(0)); } #endif // !CAPNP_LITE template -inline void Map::Entry::Builder::setKey( ::capnp::ReaderFor value) { - ::capnp::_::PointerHelpers::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void Map::Entry::Builder::setKey( + ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } template -inline ::capnp::BuilderFor Map::Entry::Builder::initKey() { - return ::capnp::_::PointerHelpers::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::BuilderFor Map::Entry::Builder::initKey() { + return ::capnp::_::PointerHelpers::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } template -inline ::capnp::BuilderFor Map::Entry::Builder::initKey(unsigned int size) { - return ::capnp::_::PointerHelpers::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::BuilderFor Map::Entry::Builder::initKey( + unsigned int size) { + return ::capnp::_::PointerHelpers::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } template inline void Map::Entry::Builder::adoptKey( ::capnp::Orphan&& value) { - ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::_::PointerHelpers::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } template inline ::capnp::Orphan Map::Entry::Builder::disownKey() { - return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + return ::capnp::_::PointerHelpers::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } template inline bool Map::Entry::Reader::hasValue() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } template inline bool Map::Entry::Builder::hasValue() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } template -inline ::capnp::ReaderFor Map::Entry::Reader::getValue() const { - return ::capnp::_::PointerHelpers::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::ReaderFor Map::Entry::Reader::getValue() + const { + return ::capnp::_::PointerHelpers::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } template -inline ::capnp::BuilderFor Map::Entry::Builder::getValue() { - return ::capnp::_::PointerHelpers::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::BuilderFor Map::Entry::Builder::getValue() { + return ::capnp::_::PointerHelpers::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE template -inline ::capnp::PipelineFor Map::Entry::Pipeline::getValue() { - return ::capnp::PipelineFor(_typeless.getPointerField(1)); +inline ::capnp::PipelineFor +Map::Entry::Pipeline::getValue() { + return ::capnp::PipelineFor(_typeless.getPointerField(1)); } #endif // !CAPNP_LITE template -inline void Map::Entry::Builder::setValue( ::capnp::ReaderFor value) { - ::capnp::_::PointerHelpers::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void Map::Entry::Builder::setValue( + ::capnp::ReaderFor value) { + ::capnp::_::PointerHelpers::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } template -inline ::capnp::BuilderFor Map::Entry::Builder::initValue() { - return ::capnp::_::PointerHelpers::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::BuilderFor Map::Entry::Builder::initValue() { + return ::capnp::_::PointerHelpers::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } template -inline ::capnp::BuilderFor Map::Entry::Builder::initValue(unsigned int size) { - return ::capnp::_::PointerHelpers::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); +inline ::capnp::BuilderFor Map::Entry::Builder::initValue( + unsigned int size) { + return ::capnp::_::PointerHelpers::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } template inline void Map::Entry::Builder::adoptValue( ::capnp::Orphan&& value) { - ::capnp::_::PointerHelpers::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::_::PointerHelpers::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } template inline ::capnp::Orphan Map::Entry::Builder::disownValue() { - return ::capnp::_::PointerHelpers::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + return ::capnp::_::PointerHelpers::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } // Map::Entry @@ -16644,22 +21830,29 @@ constexpr uint16_t Map::Entry::_capnpPrivate::pointerCount; template constexpr ::capnp::Kind Map::Entry::_capnpPrivate::kind; template -constexpr ::capnp::_::RawSchema const* Map::Entry::_capnpPrivate::schema; +constexpr ::capnp::_::RawSchema const* + Map::Entry::_capnpPrivate::schema; #endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL template -const ::capnp::_::RawBrandedSchema::Scope Map::Entry::_capnpPrivate::brandScopes[] = { - { 0xf179c194ae71718c, brandBindings + 0, 2, false}, +const ::capnp::_::RawBrandedSchema::Scope + Map::Entry::_capnpPrivate::brandScopes[] = { + {0xf179c194ae71718c, brandBindings + 0, 2, false}, }; template -const ::capnp::_::RawBrandedSchema::Binding Map::Entry::_capnpPrivate::brandBindings[] = { - ::capnp::_::brandBindingFor(), - ::capnp::_::brandBindingFor(), +const ::capnp::_::RawBrandedSchema::Binding + Map::Entry::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), }; template -const ::capnp::_::RawBrandedSchema Map::Entry::_capnpPrivate::specificBrand = { - &::capnp::schemas::s_db5514c8aaf6faea, brandScopes, nullptr, - 1, 0, nullptr -}; +const ::capnp::_::RawBrandedSchema + Map::Entry::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_db5514c8aaf6faea, + brandScopes, + nullptr, + 1, + 0, + nullptr}; #endif // !CAPNP_LITE // Map @@ -16677,439 +21870,710 @@ template constexpr ::capnp::_::RawSchema const* Map::_capnpPrivate::schema; #endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL template -const ::capnp::_::RawBrandedSchema::Scope Map::_capnpPrivate::brandScopes[] = { - { 0xf179c194ae71718c, brandBindings + 0, 2, false}, +const ::capnp::_::RawBrandedSchema::Scope + Map::_capnpPrivate::brandScopes[] = { + {0xf179c194ae71718c, brandBindings + 0, 2, false}, }; template -const ::capnp::_::RawBrandedSchema::Binding Map::_capnpPrivate::brandBindings[] = { - ::capnp::_::brandBindingFor(), - ::capnp::_::brandBindingFor(), +const ::capnp::_::RawBrandedSchema::Binding + Map::_capnpPrivate::brandBindings[] = { + ::capnp::_::brandBindingFor(), + ::capnp::_::brandBindingFor(), }; template -const ::capnp::_::RawBrandedSchema::Dependency Map::_capnpPrivate::brandDependencies[] = { - { 16777216, ::tiledb::sm::serialization::capnp::Map::Entry::_capnpPrivate::brand() }, +const ::capnp::_::RawBrandedSchema::Dependency + Map::_capnpPrivate::brandDependencies[] = { + {16777216, + ::tiledb::sm::serialization::capnp::Map::Entry:: + _capnpPrivate::brand()}, }; template -const ::capnp::_::RawBrandedSchema Map::_capnpPrivate::specificBrand = { - &::capnp::schemas::s_f179c194ae71718c, brandScopes, brandDependencies, - 1, 1, nullptr -}; +const ::capnp::_::RawBrandedSchema + Map::_capnpPrivate::specificBrand = { + &::capnp::schemas::s_f179c194ae71718c, + brandScopes, + brandDependencies, + 1, + 1, + nullptr}; #endif // !CAPNP_LITE inline bool MapEnumeration::Reader::hasEntries() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool MapEnumeration::Builder::hasEntries() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>::Reader MapEnumeration::Reader::getEntries() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>::Builder MapEnumeration::Builder::getEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void MapEnumeration::Builder::setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>::Builder MapEnumeration::Builder::initEntries(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>::Reader +MapEnumeration::Reader::getEntries() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>::Builder +MapEnumeration::Builder::getEntries() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void MapEnumeration::Builder::setEntries( + ::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>::Builder +MapEnumeration::Builder::initEntries(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void MapEnumeration::Builder::adoptEntries( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>> MapEnumeration::Builder::disownEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>> +MapEnumeration::Builder::disownEntries() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapEnumeration::Entry, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } inline bool MapEnumeration::Entry::Reader::hasKey() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool MapEnumeration::Entry::Builder::hasKey() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader MapEnumeration::Entry::Reader::getKey() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader MapEnumeration::Entry::Reader::getKey() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder MapEnumeration::Entry::Builder::getKey() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder MapEnumeration::Entry::Builder::getKey() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void MapEnumeration::Entry::Builder::setKey( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void MapEnumeration::Entry::Builder::setKey( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder MapEnumeration::Entry::Builder::initKey(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder MapEnumeration::Entry::Builder::initKey( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void MapEnumeration::Entry::Builder::adoptKey( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> MapEnumeration::Entry::Builder::disownKey() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +MapEnumeration::Entry::Builder::disownKey() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool MapEnumeration::Entry::Reader::hasValue() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool MapEnumeration::Entry::Builder::hasValue() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader MapEnumeration::Entry::Reader::getValue() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder MapEnumeration::Entry::Builder::getValue() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void MapEnumeration::Entry::Builder::setValue( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder MapEnumeration::Entry::Builder::initValue(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader +MapEnumeration::Entry::Reader::getValue() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder +MapEnumeration::Entry::Builder::getValue() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline void MapEnumeration::Entry::Builder::setValue( + ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder +MapEnumeration::Entry::Builder::initValue(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void MapEnumeration::Entry::Builder::adoptValue( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> MapEnumeration::Entry::Builder::disownValue() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>> +MapEnumeration::Entry::Builder::disownValue() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); } inline bool MapUInt32::Reader::hasEntries() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool MapUInt32::Builder::hasEntries() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>::Reader MapUInt32::Reader::getEntries() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>::Builder MapUInt32::Builder::getEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void MapUInt32::Builder::setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>::Builder MapUInt32::Builder::initEntries(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>::Reader +MapUInt32::Reader::getEntries() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>::Builder +MapUInt32::Builder::getEntries() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void MapUInt32::Builder::setEntries( + ::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>::Builder +MapUInt32::Builder::initEntries(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void MapUInt32::Builder::adoptEntries( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>> MapUInt32::Builder::disownEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt32::Entry, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>> +MapUInt32::Builder::disownEntries() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt32::Entry, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } inline bool MapUInt32::Entry::Reader::hasKey() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool MapUInt32::Entry::Builder::hasKey() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader MapUInt32::Entry::Reader::getKey() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader MapUInt32::Entry::Reader::getKey() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder MapUInt32::Entry::Builder::getKey() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder MapUInt32::Entry::Builder::getKey() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void MapUInt32::Entry::Builder::setKey( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void MapUInt32::Entry::Builder::setKey(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder MapUInt32::Entry::Builder::initKey(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder MapUInt32::Entry::Builder::initKey( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void MapUInt32::Entry::Builder::adoptKey( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> MapUInt32::Entry::Builder::disownKey() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> MapUInt32::Entry::Builder::disownKey() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint32_t MapUInt32::Entry::Reader::getValue() const { - return _reader.getDataField< ::uint32_t>( +inline ::uint32_t MapUInt32::Entry::Reader::getValue() const { + return _reader.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint32_t MapUInt32::Entry::Builder::getValue() { - return _builder.getDataField< ::uint32_t>( +inline ::uint32_t MapUInt32::Entry::Builder::getValue() { + return _builder.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void MapUInt32::Entry::Builder::setValue( ::uint32_t value) { - _builder.setDataField< ::uint32_t>( +inline void MapUInt32::Entry::Builder::setValue(::uint32_t value) { + _builder.setDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool MapInt64::Reader::hasEntries() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool MapInt64::Builder::hasEntries() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>::Reader MapInt64::Reader::getEntries() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>::Builder MapInt64::Builder::getEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void MapInt64::Builder::setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>::Builder MapInt64::Builder::initEntries(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>::Reader +MapInt64::Reader::getEntries() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>::Builder +MapInt64::Builder::getEntries() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void MapInt64::Builder::setEntries( + ::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>::Builder +MapInt64::Builder::initEntries(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void MapInt64::Builder::adoptEntries( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>> MapInt64::Builder::disownEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapInt64::Entry, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>> +MapInt64::Builder::disownEntries() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapInt64::Entry, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } inline bool MapInt64::Entry::Reader::hasKey() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool MapInt64::Entry::Builder::hasKey() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader MapInt64::Entry::Reader::getKey() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader MapInt64::Entry::Reader::getKey() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder MapInt64::Entry::Builder::getKey() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder MapInt64::Entry::Builder::getKey() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void MapInt64::Entry::Builder::setKey( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void MapInt64::Entry::Builder::setKey(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder MapInt64::Entry::Builder::initKey(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder MapInt64::Entry::Builder::initKey( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void MapInt64::Entry::Builder::adoptKey( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> MapInt64::Entry::Builder::disownKey() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> MapInt64::Entry::Builder::disownKey() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::int64_t MapInt64::Entry::Reader::getValue() const { - return _reader.getDataField< ::int64_t>( +inline ::int64_t MapInt64::Entry::Reader::getValue() const { + return _reader.getDataField<::int64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::int64_t MapInt64::Entry::Builder::getValue() { - return _builder.getDataField< ::int64_t>( +inline ::int64_t MapInt64::Entry::Builder::getValue() { + return _builder.getDataField<::int64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void MapInt64::Entry::Builder::setValue( ::int64_t value) { - _builder.setDataField< ::int64_t>( +inline void MapInt64::Entry::Builder::setValue(::int64_t value) { + _builder.setDataField<::int64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool MapUInt64::Reader::hasEntries() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool MapUInt64::Builder::hasEntries() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>::Reader MapUInt64::Reader::getEntries() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>::Builder MapUInt64::Builder::getEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void MapUInt64::Builder::setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>::Builder MapUInt64::Builder::initEntries(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>::Reader +MapUInt64::Reader::getEntries() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>::Builder +MapUInt64::Builder::getEntries() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void MapUInt64::Builder::setEntries( + ::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>::Builder +MapUInt64::Builder::initEntries(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void MapUInt64::Builder::adoptEntries( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>> MapUInt64::Builder::disownEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapUInt64::Entry, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>> +MapUInt64::Builder::disownEntries() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapUInt64::Entry, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } inline bool MapUInt64::Entry::Reader::hasKey() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool MapUInt64::Entry::Builder::hasKey() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader MapUInt64::Entry::Reader::getKey() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader MapUInt64::Entry::Reader::getKey() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder MapUInt64::Entry::Builder::getKey() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder MapUInt64::Entry::Builder::getKey() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void MapUInt64::Entry::Builder::setKey( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void MapUInt64::Entry::Builder::setKey(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder MapUInt64::Entry::Builder::initKey(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder MapUInt64::Entry::Builder::initKey( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void MapUInt64::Entry::Builder::adoptKey( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> MapUInt64::Entry::Builder::disownKey() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> MapUInt64::Entry::Builder::disownKey() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t MapUInt64::Entry::Reader::getValue() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t MapUInt64::Entry::Reader::getValue() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t MapUInt64::Entry::Builder::getValue() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t MapUInt64::Entry::Builder::getValue() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void MapUInt64::Entry::Builder::setValue( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void MapUInt64::Entry::Builder::setValue(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool MapFloat64::Reader::hasEntries() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool MapFloat64::Builder::hasEntries() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>::Reader MapFloat64::Reader::getEntries() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>::Builder MapFloat64::Builder::getEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void MapFloat64::Builder::setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>::Builder MapFloat64::Builder::initEntries(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>::Reader +MapFloat64::Reader::getEntries() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>::Builder +MapFloat64::Builder::getEntries() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void MapFloat64::Builder::setEntries( + ::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>::Builder +MapFloat64::Builder::initEntries(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void MapFloat64::Builder::adoptEntries( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>> MapFloat64::Builder::disownEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::MapFloat64::Entry, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>> +MapFloat64::Builder::disownEntries() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::MapFloat64::Entry, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } inline bool MapFloat64::Entry::Reader::hasKey() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool MapFloat64::Entry::Builder::hasKey() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader MapFloat64::Entry::Reader::getKey() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader MapFloat64::Entry::Reader::getKey() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder MapFloat64::Entry::Builder::getKey() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder MapFloat64::Entry::Builder::getKey() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void MapFloat64::Entry::Builder::setKey( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void MapFloat64::Entry::Builder::setKey(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder MapFloat64::Entry::Builder::initKey(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder MapFloat64::Entry::Builder::initKey( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void MapFloat64::Entry::Builder::adoptKey( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> MapFloat64::Entry::Builder::disownKey() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> MapFloat64::Entry::Builder::disownKey() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline double MapFloat64::Entry::Reader::getValue() const { @@ -17127,910 +22591,1276 @@ inline void MapFloat64::Entry::Builder::setValue(double value) { } inline bool Stats::Reader::hasTimers() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool Stats::Builder::hasTimers() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::MapFloat64::Reader Stats::Reader::getTimers() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapFloat64>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapFloat64::Reader +Stats::Reader::getTimers() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::MapFloat64>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::MapFloat64::Builder Stats::Builder::getTimers() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapFloat64>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapFloat64::Builder +Stats::Builder::getTimers() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::MapFloat64>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::MapFloat64::Pipeline Stats::Pipeline::getTimers() { - return ::tiledb::sm::serialization::capnp::MapFloat64::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::MapFloat64::Pipeline +Stats::Pipeline::getTimers() { + return ::tiledb::sm::serialization::capnp::MapFloat64::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void Stats::Builder::setTimers( ::tiledb::sm::serialization::capnp::MapFloat64::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapFloat64>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void Stats::Builder::setTimers( + ::tiledb::sm::serialization::capnp::MapFloat64::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::MapFloat64>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::MapFloat64::Builder Stats::Builder::initTimers() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapFloat64>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapFloat64::Builder +Stats::Builder::initTimers() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::MapFloat64>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void Stats::Builder::adoptTimers( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapFloat64>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapFloat64>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapFloat64>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::MapFloat64>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapFloat64> Stats::Builder::disownTimers() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapFloat64>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapFloat64> +Stats::Builder::disownTimers() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::MapFloat64>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Stats::Reader::hasCounters() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool Stats::Builder::hasCounters() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::MapUInt64::Reader Stats::Reader::getCounters() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapUInt64::Reader +Stats::Reader::getCounters() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder Stats::Builder::getCounters() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder +Stats::Builder::getCounters() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline Stats::Pipeline::getCounters() { - return ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline(_typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline +Stats::Pipeline::getCounters() { + return ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline( + _typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void Stats::Builder::setCounters( ::tiledb::sm::serialization::capnp::MapUInt64::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void Stats::Builder::setCounters( + ::tiledb::sm::serialization::capnp::MapUInt64::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>:: + set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder Stats::Builder::initCounters() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder +Stats::Builder::initCounters() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void Stats::Builder::adoptCounters( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapUInt64>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapUInt64>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapUInt64> Stats::Builder::disownCounters() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapUInt64> +Stats::Builder::disownCounters() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool UnorderedWriterState::Reader::getIsCoordsPass() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool UnorderedWriterState::Builder::getIsCoordsPass() { - return _builder.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void UnorderedWriterState::Builder::setIsCoordsPass(bool value) { - _builder.setDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool UnorderedWriterState::Reader::hasCellPos() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool UnorderedWriterState::Builder::hasCellPos() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader UnorderedWriterState::Reader::getCellPos() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder UnorderedWriterState::Builder::getCellPos() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void UnorderedWriterState::Builder::setCellPos( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline void UnorderedWriterState::Builder::setCellPos(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder UnorderedWriterState::Builder::initCellPos(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +UnorderedWriterState::Reader::getCellPos() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +UnorderedWriterState::Builder::getCellPos() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void UnorderedWriterState::Builder::setCellPos( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline void UnorderedWriterState::Builder::setCellPos( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +UnorderedWriterState::Builder::initCellPos(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void UnorderedWriterState::Builder::adoptCellPos( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> UnorderedWriterState::Builder::disownCellPos() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +UnorderedWriterState::Builder::disownCellPos() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool UnorderedWriterState::Reader::hasCoordDups() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool UnorderedWriterState::Builder::hasCoordDups() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader UnorderedWriterState::Reader::getCoordDups() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder UnorderedWriterState::Builder::getCoordDups() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void UnorderedWriterState::Builder::setCoordDups( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline void UnorderedWriterState::Builder::setCoordDups(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder UnorderedWriterState::Builder::initCoordDups(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +UnorderedWriterState::Reader::getCoordDups() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +UnorderedWriterState::Builder::getCoordDups() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void UnorderedWriterState::Builder::setCoordDups( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline void UnorderedWriterState::Builder::setCoordDups( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +UnorderedWriterState::Builder::initCoordDups(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void UnorderedWriterState::Builder::adoptCoordDups( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> UnorderedWriterState::Builder::disownCoordDups() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +UnorderedWriterState::Builder::disownCoordDups() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool UnorderedWriterState::Reader::hasFragMeta() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool UnorderedWriterState::Builder::hasFragMeta() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader UnorderedWriterState::Reader::getFragMeta() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader +UnorderedWriterState::Reader::getFragMeta() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder UnorderedWriterState::Builder::getFragMeta() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder +UnorderedWriterState::Builder::getFragMeta() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline UnorderedWriterState::Pipeline::getFragMeta() { - return ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline(_typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline +UnorderedWriterState::Pipeline::getFragMeta() { + return ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline( + _typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void UnorderedWriterState::Builder::setFragMeta( ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void UnorderedWriterState::Builder::setFragMeta( + ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder UnorderedWriterState::Builder::initFragMeta() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder +UnorderedWriterState::Builder::initFragMeta() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::FragmentMetadata>:: + init(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void UnorderedWriterState::Builder::adoptFragMeta( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata> UnorderedWriterState::Builder::disownFragMeta() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata>&& + value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::FragmentMetadata>:: + adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata> +UnorderedWriterState::Builder::disownFragMeta() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::FragmentMetadata>:: + disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Writer::Reader::getCheckCoordDups() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool Writer::Builder::getCheckCoordDups() { - return _builder.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void Writer::Builder::setCheckCoordDups(bool value) { - _builder.setDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool Writer::Reader::getCheckCoordOOB() const { - return _reader.getDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline bool Writer::Builder::getCheckCoordOOB() { - return _builder.getDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline void Writer::Builder::setCheckCoordOOB(bool value) { - _builder.setDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool Writer::Reader::getDedupCoords() const { - return _reader.getDataField( - ::capnp::bounded<2>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS); } inline bool Writer::Builder::getDedupCoords() { - return _builder.getDataField( - ::capnp::bounded<2>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS); } inline void Writer::Builder::setDedupCoords(bool value) { - _builder.setDataField( - ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool Writer::Reader::hasSubarray() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool Writer::Builder::hasSubarray() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Reader Writer::Reader::getSubarray() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Reader +Writer::Reader::getSubarray() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Builder Writer::Builder::getSubarray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Builder +Writer::Builder::getSubarray() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline Writer::Pipeline::getSubarray() { - return ::tiledb::sm::serialization::capnp::DomainArray::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline +Writer::Pipeline::getSubarray() { + return ::tiledb::sm::serialization::capnp::DomainArray::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void Writer::Builder::setSubarray( ::tiledb::sm::serialization::capnp::DomainArray::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void Writer::Builder::setSubarray( + ::tiledb::sm::serialization::capnp::DomainArray::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Builder Writer::Builder::initSubarray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Builder +Writer::Builder::initSubarray() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void Writer::Builder::adoptSubarray( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray> Writer::Builder::disownSubarray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray> +Writer::Builder::disownSubarray() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Writer::Reader::hasSubarrayRanges() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool Writer::Builder::hasSubarrayRanges() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Subarray::Reader Writer::Reader::getSubarrayRanges() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Reader +Writer::Reader::getSubarrayRanges() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder Writer::Builder::getSubarrayRanges() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder +Writer::Builder::getSubarrayRanges() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline Writer::Pipeline::getSubarrayRanges() { - return ::tiledb::sm::serialization::capnp::Subarray::Pipeline(_typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline +Writer::Pipeline::getSubarrayRanges() { + return ::tiledb::sm::serialization::capnp::Subarray::Pipeline( + _typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void Writer::Builder::setSubarrayRanges( ::tiledb::sm::serialization::capnp::Subarray::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void Writer::Builder::setSubarrayRanges( + ::tiledb::sm::serialization::capnp::Subarray::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder Writer::Builder::initSubarrayRanges() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder +Writer::Builder::initSubarrayRanges() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void Writer::Builder::adoptSubarrayRanges( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> Writer::Builder::disownSubarrayRanges() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> +Writer::Builder::disownSubarrayRanges() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Writer::Reader::hasStats() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool Writer::Builder::hasStats() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Stats::Reader Writer::Reader::getStats() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Reader +Writer::Reader::getStats() const { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + get(_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder Writer::Builder::getStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder +Writer::Builder::getStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + get(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Stats::Pipeline Writer::Pipeline::getStats() { - return ::tiledb::sm::serialization::capnp::Stats::Pipeline(_typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::Stats::Pipeline +Writer::Pipeline::getStats() { + return ::tiledb::sm::serialization::capnp::Stats::Pipeline( + _typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void Writer::Builder::setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void Writer::Builder::setStats( + ::tiledb::sm::serialization::capnp::Stats::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder Writer::Builder::initStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder +Writer::Builder::initStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + init(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void Writer::Builder::adoptStats( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> Writer::Builder::disownStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> +Writer::Builder::disownStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Writer::Reader::hasGlobalWriteStateV1() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool Writer::Builder::hasGlobalWriteStateV1() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Reader Writer::Reader::getGlobalWriteStateV1() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GlobalWriteState>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Reader +Writer::Reader::getGlobalWriteStateV1() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::GlobalWriteState>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Builder Writer::Builder::getGlobalWriteStateV1() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GlobalWriteState>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Builder +Writer::Builder::getGlobalWriteStateV1() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::GlobalWriteState>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Pipeline Writer::Pipeline::getGlobalWriteStateV1() { - return ::tiledb::sm::serialization::capnp::GlobalWriteState::Pipeline(_typeless.getPointerField(3)); +inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Pipeline +Writer::Pipeline::getGlobalWriteStateV1() { + return ::tiledb::sm::serialization::capnp::GlobalWriteState::Pipeline( + _typeless.getPointerField(3)); } #endif // !CAPNP_LITE -inline void Writer::Builder::setGlobalWriteStateV1( ::tiledb::sm::serialization::capnp::GlobalWriteState::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GlobalWriteState>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); +inline void Writer::Builder::setGlobalWriteStateV1( + ::tiledb::sm::serialization::capnp::GlobalWriteState::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::GlobalWriteState>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Builder Writer::Builder::initGlobalWriteStateV1() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GlobalWriteState>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::GlobalWriteState::Builder +Writer::Builder::initGlobalWriteStateV1() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::GlobalWriteState>:: + init(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void Writer::Builder::adoptGlobalWriteStateV1( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GlobalWriteState>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GlobalWriteState>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GlobalWriteState> Writer::Builder::disownGlobalWriteStateV1() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GlobalWriteState>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::GlobalWriteState>&& + value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::GlobalWriteState>:: + adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::GlobalWriteState> +Writer::Builder::disownGlobalWriteStateV1() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::GlobalWriteState>:: + disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool Writer::Reader::hasUnorderedWriterState() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool Writer::Builder::hasUnorderedWriterState() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Reader Writer::Reader::getUnorderedWriterState() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::UnorderedWriterState>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Reader +Writer::Reader::getUnorderedWriterState() const { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::UnorderedWriterState>:: + get(_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Builder Writer::Builder::getUnorderedWriterState() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::UnorderedWriterState>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Builder +Writer::Builder::getUnorderedWriterState() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::UnorderedWriterState>:: + get(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Pipeline Writer::Pipeline::getUnorderedWriterState() { - return ::tiledb::sm::serialization::capnp::UnorderedWriterState::Pipeline(_typeless.getPointerField(4)); +inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Pipeline +Writer::Pipeline::getUnorderedWriterState() { + return ::tiledb::sm::serialization::capnp::UnorderedWriterState::Pipeline( + _typeless.getPointerField(4)); } #endif // !CAPNP_LITE -inline void Writer::Builder::setUnorderedWriterState( ::tiledb::sm::serialization::capnp::UnorderedWriterState::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::UnorderedWriterState>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); +inline void Writer::Builder::setUnorderedWriterState( + ::tiledb::sm::serialization::capnp::UnorderedWriterState::Reader value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::UnorderedWriterState>:: + set(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Builder Writer::Builder::initUnorderedWriterState() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::UnorderedWriterState>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::UnorderedWriterState::Builder +Writer::Builder::initUnorderedWriterState() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::UnorderedWriterState>:: + init(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline void Writer::Builder::adoptUnorderedWriterState( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::UnorderedWriterState>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::UnorderedWriterState>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::UnorderedWriterState> Writer::Builder::disownUnorderedWriterState() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::UnorderedWriterState>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::UnorderedWriterState>&& + value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::UnorderedWriterState>:: + adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::UnorderedWriterState> +Writer::Builder::disownUnorderedWriterState() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::UnorderedWriterState>:: + disown( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool SubarrayRanges::Reader::hasType() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool SubarrayRanges::Builder::hasType() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader SubarrayRanges::Reader::getType() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader SubarrayRanges::Reader::getType() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder SubarrayRanges::Builder::getType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder SubarrayRanges::Builder::getType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void SubarrayRanges::Builder::setType( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void SubarrayRanges::Builder::setType(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder SubarrayRanges::Builder::initType(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder SubarrayRanges::Builder::initType( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void SubarrayRanges::Builder::adoptType( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> SubarrayRanges::Builder::disownType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> SubarrayRanges::Builder::disownType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool SubarrayRanges::Reader::getHasDefaultRange() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool SubarrayRanges::Builder::getHasDefaultRange() { - return _builder.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void SubarrayRanges::Builder::setHasDefaultRange(bool value) { - _builder.setDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool SubarrayRanges::Reader::hasBuffer() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool SubarrayRanges::Builder::hasBuffer() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Data::Reader SubarrayRanges::Reader::getBuffer() const { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Data::Reader SubarrayRanges::Reader::getBuffer() const { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Data::Builder SubarrayRanges::Builder::getBuffer() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Data::Builder SubarrayRanges::Builder::getBuffer() { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void SubarrayRanges::Builder::setBuffer( ::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void SubarrayRanges::Builder::setBuffer(::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Data>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::capnp::Data::Builder SubarrayRanges::Builder::initBuffer(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); +inline ::capnp::Data::Builder SubarrayRanges::Builder::initBuffer( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Data>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void SubarrayRanges::Builder::adoptBuffer( - ::capnp::Orphan< ::capnp::Data>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Data>&& value) { + ::capnp::_::PointerHelpers<::capnp::Data>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Data> SubarrayRanges::Builder::disownBuffer() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Data> SubarrayRanges::Builder::disownBuffer() { + return ::capnp::_::PointerHelpers<::capnp::Data>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool SubarrayRanges::Reader::hasBufferSizes() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool SubarrayRanges::Builder::hasBufferSizes() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader SubarrayRanges::Reader::getBufferSizes() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder SubarrayRanges::Builder::getBufferSizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void SubarrayRanges::Builder::setBufferSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline void SubarrayRanges::Builder::setBufferSizes(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder SubarrayRanges::Builder::initBufferSizes(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +SubarrayRanges::Reader::getBufferSizes() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +SubarrayRanges::Builder::getBufferSizes() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void SubarrayRanges::Builder::setBufferSizes( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline void SubarrayRanges::Builder::setBufferSizes( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +SubarrayRanges::Builder::initBufferSizes(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void SubarrayRanges::Builder::adoptBufferSizes( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> SubarrayRanges::Builder::disownBufferSizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +SubarrayRanges::Builder::disownBufferSizes() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool SubarrayRanges::Reader::hasBufferStartSizes() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool SubarrayRanges::Builder::hasBufferStartSizes() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader SubarrayRanges::Reader::getBufferStartSizes() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder SubarrayRanges::Builder::getBufferStartSizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline void SubarrayRanges::Builder::setBufferStartSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline void SubarrayRanges::Builder::setBufferStartSizes(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder SubarrayRanges::Builder::initBufferStartSizes(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +SubarrayRanges::Reader::getBufferStartSizes() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +SubarrayRanges::Builder::getBufferStartSizes() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void SubarrayRanges::Builder::setBufferStartSizes( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline void SubarrayRanges::Builder::setBufferStartSizes( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +SubarrayRanges::Builder::initBufferStartSizes(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + size); } inline void SubarrayRanges::Builder::adoptBufferStartSizes( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> SubarrayRanges::Builder::disownBufferStartSizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} - -inline ::uint32_t LabelSubarrayRanges::Reader::getDimensionId() const { - return _reader.getDataField< ::uint32_t>( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +SubarrayRanges::Builder::disownBufferStartSizes() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline ::uint32_t LabelSubarrayRanges::Reader::getDimensionId() const { + return _reader.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint32_t LabelSubarrayRanges::Builder::getDimensionId() { - return _builder.getDataField< ::uint32_t>( +inline ::uint32_t LabelSubarrayRanges::Builder::getDimensionId() { + return _builder.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void LabelSubarrayRanges::Builder::setDimensionId( ::uint32_t value) { - _builder.setDataField< ::uint32_t>( +inline void LabelSubarrayRanges::Builder::setDimensionId(::uint32_t value) { + _builder.setDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool LabelSubarrayRanges::Reader::hasName() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool LabelSubarrayRanges::Builder::hasName() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader LabelSubarrayRanges::Reader::getName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader LabelSubarrayRanges::Reader::getName() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder LabelSubarrayRanges::Builder::getName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder LabelSubarrayRanges::Builder::getName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void LabelSubarrayRanges::Builder::setName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void LabelSubarrayRanges::Builder::setName(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder LabelSubarrayRanges::Builder::initName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder LabelSubarrayRanges::Builder::initName( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void LabelSubarrayRanges::Builder::adoptName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> LabelSubarrayRanges::Builder::disownName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +LabelSubarrayRanges::Builder::disownName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool LabelSubarrayRanges::Reader::hasRanges() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool LabelSubarrayRanges::Builder::hasRanges() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Reader LabelSubarrayRanges::Reader::getRanges() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayRanges>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Reader +LabelSubarrayRanges::Reader::getRanges() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::SubarrayRanges>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Builder LabelSubarrayRanges::Builder::getRanges() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayRanges>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Builder +LabelSubarrayRanges::Builder::getRanges() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::SubarrayRanges>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Pipeline LabelSubarrayRanges::Pipeline::getRanges() { - return ::tiledb::sm::serialization::capnp::SubarrayRanges::Pipeline(_typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Pipeline +LabelSubarrayRanges::Pipeline::getRanges() { + return ::tiledb::sm::serialization::capnp::SubarrayRanges::Pipeline( + _typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void LabelSubarrayRanges::Builder::setRanges( ::tiledb::sm::serialization::capnp::SubarrayRanges::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayRanges>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void LabelSubarrayRanges::Builder::setRanges( + ::tiledb::sm::serialization::capnp::SubarrayRanges::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::SubarrayRanges>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Builder LabelSubarrayRanges::Builder::initRanges() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayRanges>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SubarrayRanges::Builder +LabelSubarrayRanges::Builder::initRanges() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::SubarrayRanges>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void LabelSubarrayRanges::Builder::adoptRanges( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayRanges>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayRanges>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayRanges>&& + value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::SubarrayRanges>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayRanges> LabelSubarrayRanges::Builder::disownRanges() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayRanges>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayRanges> +LabelSubarrayRanges::Builder::disownRanges() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayRanges>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Subarray::Reader::hasLayout() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool Subarray::Builder::hasLayout() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Subarray::Reader::getLayout() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Subarray::Reader::getLayout() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Subarray::Builder::getLayout() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Subarray::Builder::getLayout() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Subarray::Builder::setLayout( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void Subarray::Builder::setLayout(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Subarray::Builder::initLayout(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Subarray::Builder::initLayout(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void Subarray::Builder::adoptLayout( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Subarray::Builder::disownLayout() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Subarray::Builder::disownLayout() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Subarray::Reader::hasRanges() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool Subarray::Builder::hasRanges() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Reader Subarray::Reader::getRanges() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Builder Subarray::Builder::getRanges() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void Subarray::Builder::setRanges( ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Builder Subarray::Builder::initRanges(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>::Reader +Subarray::Reader::getRanges() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>::Builder +Subarray::Builder::getRanges() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline void Subarray::Builder::setRanges( + ::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>::Builder +Subarray::Builder::initRanges(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void Subarray::Builder::adoptRanges( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>> Subarray::Builder::disownRanges() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>> +Subarray::Builder::disownRanges() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); } inline bool Subarray::Reader::hasStats() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool Subarray::Builder::hasStats() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Stats::Reader Subarray::Reader::getStats() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Reader +Subarray::Reader::getStats() const { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + get(_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder Subarray::Builder::getStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder +Subarray::Builder::getStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + get(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Stats::Pipeline Subarray::Pipeline::getStats() { - return ::tiledb::sm::serialization::capnp::Stats::Pipeline(_typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::Stats::Pipeline +Subarray::Pipeline::getStats() { + return ::tiledb::sm::serialization::capnp::Stats::Pipeline( + _typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void Subarray::Builder::setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void Subarray::Builder::setStats( + ::tiledb::sm::serialization::capnp::Stats::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder Subarray::Builder::initStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder +Subarray::Builder::initStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + init(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void Subarray::Builder::adoptStats( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> Subarray::Builder::disownStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> +Subarray::Builder::disownStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Subarray::Reader::hasRelevantFragments() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool Subarray::Builder::hasRelevantFragments() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader Subarray::Reader::getRelevantFragments() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder Subarray::Builder::getRelevantFragments() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline void Subarray::Builder::setRelevantFragments( ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline void Subarray::Builder::setRelevantFragments(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder Subarray::Builder::initRelevantFragments(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader +Subarray::Reader::getRelevantFragments() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder +Subarray::Builder::getRelevantFragments() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void Subarray::Builder::setRelevantFragments( + ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline void Subarray::Builder::setRelevantFragments( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>::Builder +Subarray::Builder::initRelevantFragments(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + size); } inline void Subarray::Builder::adoptRelevantFragments( - ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>> Subarray::Builder::disownRelevantFragments() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>> +Subarray::Builder::disownRelevantFragments() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint32_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool Subarray::Reader::hasLabelRanges() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool Subarray::Builder::hasLabelRanges() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>::Reader Subarray::Reader::getLabelRanges() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>::Builder Subarray::Builder::getLabelRanges() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline void Subarray::Builder::setLabelRanges( ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>::Builder Subarray::Builder::initLabelRanges(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>::Reader +Subarray::Reader::getLabelRanges() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<4>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>::Builder +Subarray::Builder::getLabelRanges() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<4>() * + ::capnp::POINTERS)); +} +inline void Subarray::Builder::setLabelRanges( + ::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>::Builder +Subarray::Builder::initLabelRanges(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + size); } inline void Subarray::Builder::adoptLabelRanges( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>> Subarray::Builder::disownLabelRanges() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>> +Subarray::Builder::disownLabelRanges() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::LabelSubarrayRanges, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<4>() * + ::capnp::POINTERS)); } inline bool Subarray::Reader::hasAttributeRanges() const { - return !_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } inline bool Subarray::Builder::hasAttributeRanges() { - return !_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Reader Subarray::Reader::getAttributeRanges() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>>::get(_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Builder Subarray::Builder::getAttributeRanges() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>>::get(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Pipeline Subarray::Pipeline::getAttributeRanges() { - return ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Pipeline(_typeless.getPointerField(5)); -} -#endif // !CAPNP_LITE -inline void Subarray::Builder::setAttributeRanges( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>>::set(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), value); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>::Builder Subarray::Builder::initAttributeRanges() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>>::init(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); + return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); +} +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>::Reader +Subarray::Reader::getAttributeRanges() const { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>>:: + get(_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>::Builder +Subarray::Builder::getAttributeRanges() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>>:: + get(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>::Pipeline +Subarray::Pipeline::getAttributeRanges() { + return ::tiledb::sm::serialization::capnp:: + Map<::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>:: + Pipeline(_typeless.getPointerField(5)); +} +#endif // !CAPNP_LITE +inline void Subarray::Builder::setAttributeRanges( + ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>>:: + set(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + value); +} +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>::Builder +Subarray::Builder::initAttributeRanges() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>>:: + init(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } inline void Subarray::Builder::adoptAttributeRanges( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>>::adopt(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>> Subarray::Builder::disownAttributeRanges() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::SubarrayRanges>>::disown(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>>:: + adopt( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>> +Subarray::Builder::disownAttributeRanges() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::SubarrayRanges>>:: + disown( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool Subarray::Reader::getCoalesceRanges() const { @@ -18048,305 +23878,432 @@ inline void Subarray::Builder::setCoalesceRanges(bool value) { } inline bool SubarrayPartitioner::Reader::hasSubarray() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool SubarrayPartitioner::Builder::hasSubarray() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Subarray::Reader SubarrayPartitioner::Reader::getSubarray() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Reader +SubarrayPartitioner::Reader::getSubarray() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder SubarrayPartitioner::Builder::getSubarray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder +SubarrayPartitioner::Builder::getSubarray() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline SubarrayPartitioner::Pipeline::getSubarray() { - return ::tiledb::sm::serialization::capnp::Subarray::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline +SubarrayPartitioner::Pipeline::getSubarray() { + return ::tiledb::sm::serialization::capnp::Subarray::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void SubarrayPartitioner::Builder::setSubarray( ::tiledb::sm::serialization::capnp::Subarray::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void SubarrayPartitioner::Builder::setSubarray( + ::tiledb::sm::serialization::capnp::Subarray::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder SubarrayPartitioner::Builder::initSubarray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder +SubarrayPartitioner::Builder::initSubarray() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void SubarrayPartitioner::Builder::adoptSubarray( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> SubarrayPartitioner::Builder::disownSubarray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> +SubarrayPartitioner::Builder::disownSubarray() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool SubarrayPartitioner::Reader::hasBudget() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool SubarrayPartitioner::Builder::hasBudget() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>::Reader SubarrayPartitioner::Reader::getBudget() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>::Builder SubarrayPartitioner::Builder::getBudget() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void SubarrayPartitioner::Builder::setBudget( ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>::Builder SubarrayPartitioner::Builder::initBudget(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>::Reader +SubarrayPartitioner::Reader::getBudget() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>::Builder +SubarrayPartitioner::Builder::getBudget() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline void SubarrayPartitioner::Builder::setBudget( + ::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>::Builder +SubarrayPartitioner::Builder::initBudget(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void SubarrayPartitioner::Builder::adoptBudget( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>> SubarrayPartitioner::Builder::disownBudget() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferSize, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>> +SubarrayPartitioner::Builder::disownBudget() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferSize, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); } inline bool SubarrayPartitioner::Reader::hasCurrent() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool SubarrayPartitioner::Builder::hasCurrent() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); -} -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Reader SubarrayPartitioner::Reader::getCurrent() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Builder SubarrayPartitioner::Builder::getCurrent() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Pipeline SubarrayPartitioner::Pipeline::getCurrent() { - return ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Pipeline(_typeless.getPointerField(2)); -} -#endif // !CAPNP_LITE -inline void SubarrayPartitioner::Builder::setCurrent( ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo::Builder SubarrayPartitioner::Builder::initCurrent() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); +} +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo:: + Reader + SubarrayPartitioner::Reader::getCurrent() const { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>:: + get(_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo:: + Builder + SubarrayPartitioner::Builder::getCurrent() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>:: + get(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo:: + Pipeline + SubarrayPartitioner::Pipeline::getCurrent() { + return ::tiledb::sm::serialization::capnp::SubarrayPartitioner:: + PartitionInfo::Pipeline(_typeless.getPointerField(2)); +} +#endif // !CAPNP_LITE +inline void SubarrayPartitioner::Builder::setCurrent( + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo:: + Reader value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>:: + set(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo:: + Builder + SubarrayPartitioner::Builder::initCurrent() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>:: + init(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void SubarrayPartitioner::Builder::adoptCurrent( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo> SubarrayPartitioner::Builder::disownCurrent() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayPartitioner:: + PartitionInfo>&& value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>:: + adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo> +SubarrayPartitioner::Builder::disownCurrent() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::PartitionInfo>:: + disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool SubarrayPartitioner::Reader::hasState() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool SubarrayPartitioner::Builder::hasState() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); -} -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Reader SubarrayPartitioner::Reader::getState() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Builder SubarrayPartitioner::Builder::getState() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Pipeline SubarrayPartitioner::Pipeline::getState() { - return ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Pipeline(_typeless.getPointerField(3)); -} -#endif // !CAPNP_LITE -inline void SubarrayPartitioner::Builder::setState( ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Builder SubarrayPartitioner::Builder::initState() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); +} +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Reader +SubarrayPartitioner::Reader::getState() const { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>:: + get(_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Builder +SubarrayPartitioner::Builder::getState() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>:: + get(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Pipeline +SubarrayPartitioner::Pipeline::getState() { + return ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State:: + Pipeline(_typeless.getPointerField(3)); +} +#endif // !CAPNP_LITE +inline void SubarrayPartitioner::Builder::setState( + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Reader + value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>:: + set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State::Builder +SubarrayPartitioner::Builder::initState() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>:: + init(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void SubarrayPartitioner::Builder::adoptState( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State> SubarrayPartitioner::Builder::disownState() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} - -inline ::uint64_t SubarrayPartitioner::Reader::getMemoryBudget() const { - return _reader.getDataField< ::uint64_t>( + ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>&& + value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>:: + adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State> +SubarrayPartitioner::Builder::disownState() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::State>:: + disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline ::uint64_t SubarrayPartitioner::Reader::getMemoryBudget() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t SubarrayPartitioner::Builder::getMemoryBudget() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t SubarrayPartitioner::Builder::getMemoryBudget() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void SubarrayPartitioner::Builder::setMemoryBudget( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void SubarrayPartitioner::Builder::setMemoryBudget(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t SubarrayPartitioner::Reader::getMemoryBudgetVar() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t SubarrayPartitioner::Reader::getMemoryBudgetVar() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t SubarrayPartitioner::Builder::getMemoryBudgetVar() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t SubarrayPartitioner::Builder::getMemoryBudgetVar() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void SubarrayPartitioner::Builder::setMemoryBudgetVar( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void SubarrayPartitioner::Builder::setMemoryBudgetVar(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t SubarrayPartitioner::Reader::getMemoryBudgetValidity() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t SubarrayPartitioner::Reader::getMemoryBudgetValidity() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t SubarrayPartitioner::Builder::getMemoryBudgetValidity() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t SubarrayPartitioner::Builder::getMemoryBudgetValidity() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void SubarrayPartitioner::Builder::setMemoryBudgetValidity( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void SubarrayPartitioner::Builder::setMemoryBudgetValidity( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool SubarrayPartitioner::Reader::hasStats() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool SubarrayPartitioner::Builder::hasStats() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Stats::Reader SubarrayPartitioner::Reader::getStats() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Reader +SubarrayPartitioner::Reader::getStats() const { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + get(_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder SubarrayPartitioner::Builder::getStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder +SubarrayPartitioner::Builder::getStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + get(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Stats::Pipeline SubarrayPartitioner::Pipeline::getStats() { - return ::tiledb::sm::serialization::capnp::Stats::Pipeline(_typeless.getPointerField(4)); +inline ::tiledb::sm::serialization::capnp::Stats::Pipeline +SubarrayPartitioner::Pipeline::getStats() { + return ::tiledb::sm::serialization::capnp::Stats::Pipeline( + _typeless.getPointerField(4)); } #endif // !CAPNP_LITE -inline void SubarrayPartitioner::Builder::setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); +inline void SubarrayPartitioner::Builder::setStats( + ::tiledb::sm::serialization::capnp::Stats::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder SubarrayPartitioner::Builder::initStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder +SubarrayPartitioner::Builder::initStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + init(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline void SubarrayPartitioner::Builder::adoptStats( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> SubarrayPartitioner::Builder::disownStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> +SubarrayPartitioner::Builder::disownStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + disown( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool SubarrayPartitioner::PartitionInfo::Reader::hasSubarray() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool SubarrayPartitioner::PartitionInfo::Builder::hasSubarray() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Subarray::Reader SubarrayPartitioner::PartitionInfo::Reader::getSubarray() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Reader +SubarrayPartitioner::PartitionInfo::Reader::getSubarray() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder SubarrayPartitioner::PartitionInfo::Builder::getSubarray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder +SubarrayPartitioner::PartitionInfo::Builder::getSubarray() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline SubarrayPartitioner::PartitionInfo::Pipeline::getSubarray() { - return ::tiledb::sm::serialization::capnp::Subarray::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline +SubarrayPartitioner::PartitionInfo::Pipeline::getSubarray() { + return ::tiledb::sm::serialization::capnp::Subarray::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void SubarrayPartitioner::PartitionInfo::Builder::setSubarray( ::tiledb::sm::serialization::capnp::Subarray::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void SubarrayPartitioner::PartitionInfo::Builder::setSubarray( + ::tiledb::sm::serialization::capnp::Subarray::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder SubarrayPartitioner::PartitionInfo::Builder::initSubarray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder +SubarrayPartitioner::PartitionInfo::Builder::initSubarray() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void SubarrayPartitioner::PartitionInfo::Builder::adoptSubarray( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> SubarrayPartitioner::PartitionInfo::Builder::disownSubarray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> +SubarrayPartitioner::PartitionInfo::Builder::disownSubarray() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t SubarrayPartitioner::PartitionInfo::Reader::getStart() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t SubarrayPartitioner::PartitionInfo::Reader::getStart() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t SubarrayPartitioner::PartitionInfo::Builder::getStart() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t SubarrayPartitioner::PartitionInfo::Builder::getStart() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void SubarrayPartitioner::PartitionInfo::Builder::setStart( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void SubarrayPartitioner::PartitionInfo::Builder::setStart( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t SubarrayPartitioner::PartitionInfo::Reader::getEnd() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t SubarrayPartitioner::PartitionInfo::Reader::getEnd() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t SubarrayPartitioner::PartitionInfo::Builder::getEnd() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t SubarrayPartitioner::PartitionInfo::Builder::getEnd() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void SubarrayPartitioner::PartitionInfo::Builder::setEnd( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void SubarrayPartitioner::PartitionInfo::Builder::setEnd( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline bool SubarrayPartitioner::PartitionInfo::Reader::getSplitMultiRange() const { +inline bool SubarrayPartitioner::PartitionInfo::Reader::getSplitMultiRange() + const { return _reader.getDataField( ::capnp::bounded<128>() * ::capnp::ELEMENTS); } @@ -18355,1665 +24312,2208 @@ inline bool SubarrayPartitioner::PartitionInfo::Builder::getSplitMultiRange() { return _builder.getDataField( ::capnp::bounded<128>() * ::capnp::ELEMENTS); } -inline void SubarrayPartitioner::PartitionInfo::Builder::setSplitMultiRange(bool value) { +inline void SubarrayPartitioner::PartitionInfo::Builder::setSplitMultiRange( + bool value) { _builder.setDataField( ::capnp::bounded<128>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t SubarrayPartitioner::State::Reader::getStart() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t SubarrayPartitioner::State::Reader::getStart() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t SubarrayPartitioner::State::Builder::getStart() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t SubarrayPartitioner::State::Builder::getStart() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void SubarrayPartitioner::State::Builder::setStart( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void SubarrayPartitioner::State::Builder::setStart(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t SubarrayPartitioner::State::Reader::getEnd() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t SubarrayPartitioner::State::Reader::getEnd() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t SubarrayPartitioner::State::Builder::getEnd() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t SubarrayPartitioner::State::Builder::getEnd() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void SubarrayPartitioner::State::Builder::setEnd( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void SubarrayPartitioner::State::Builder::setEnd(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool SubarrayPartitioner::State::Reader::hasSingleRange() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool SubarrayPartitioner::State::Builder::hasSingleRange() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Reader SubarrayPartitioner::State::Reader::getSingleRange() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Builder SubarrayPartitioner::State::Builder::getSingleRange() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void SubarrayPartitioner::State::Builder::setSingleRange( ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Builder SubarrayPartitioner::State::Builder::initSingleRange(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>::Reader +SubarrayPartitioner::State::Reader::getSingleRange() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>::Builder +SubarrayPartitioner::State::Builder::getSingleRange() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void SubarrayPartitioner::State::Builder::setSingleRange( + ::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>::Builder +SubarrayPartitioner::State::Builder::initSingleRange(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void SubarrayPartitioner::State::Builder::adoptSingleRange( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>> SubarrayPartitioner::State::Builder::disownSingleRange() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>> +SubarrayPartitioner::State::Builder::disownSingleRange() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } inline bool SubarrayPartitioner::State::Reader::hasMultiRange() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool SubarrayPartitioner::State::Builder::hasMultiRange() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Reader SubarrayPartitioner::State::Reader::getMultiRange() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Builder SubarrayPartitioner::State::Builder::getMultiRange() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void SubarrayPartitioner::State::Builder::setMultiRange( ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>::Builder SubarrayPartitioner::State::Builder::initMultiRange(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>::Reader +SubarrayPartitioner::State::Reader::getMultiRange() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>::Builder +SubarrayPartitioner::State::Builder::getMultiRange() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline void SubarrayPartitioner::State::Builder::setMultiRange( + ::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>::Builder +SubarrayPartitioner::State::Builder::initMultiRange(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void SubarrayPartitioner::State::Builder::adoptMultiRange( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>> SubarrayPartitioner::State::Builder::disownMultiRange() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Subarray, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>> +SubarrayPartitioner::State::Builder::disownMultiRange() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Subarray, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); } inline bool ReadState::Reader::getOverflowed() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool ReadState::Builder::getOverflowed() { - return _builder.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void ReadState::Builder::setOverflowed(bool value) { - _builder.setDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool ReadState::Reader::getUnsplittable() const { - return _reader.getDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline bool ReadState::Builder::getUnsplittable() { - return _builder.getDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline void ReadState::Builder::setUnsplittable(bool value) { - _builder.setDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool ReadState::Reader::getInitialized() const { - return _reader.getDataField( - ::capnp::bounded<2>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS); } inline bool ReadState::Builder::getInitialized() { - return _builder.getDataField( - ::capnp::bounded<2>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS); } inline void ReadState::Builder::setInitialized(bool value) { - _builder.setDataField( - ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool ReadState::Reader::hasSubarrayPartitioner() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ReadState::Builder::hasSubarrayPartitioner() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Reader ReadState::Reader::getSubarrayPartitioner() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Reader +ReadState::Reader::getSubarrayPartitioner() const { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner>:: + get(_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Builder ReadState::Builder::getSubarrayPartitioner() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Builder +ReadState::Builder::getSubarrayPartitioner() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner>:: + get(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Pipeline ReadState::Pipeline::getSubarrayPartitioner() { - return ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Pipeline +ReadState::Pipeline::getSubarrayPartitioner() { + return ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void ReadState::Builder::setSubarrayPartitioner( ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void ReadState::Builder::setSubarrayPartitioner( + ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Reader value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Builder ReadState::Builder::initSubarrayPartitioner() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SubarrayPartitioner::Builder +ReadState::Builder::initSubarrayPartitioner() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner>:: + init(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void ReadState::Builder::adoptSubarrayPartitioner( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SubarrayPartitioner> ReadState::Builder::disownSubarrayPartitioner() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SubarrayPartitioner>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayPartitioner>&& + value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::SubarrayPartitioner> +ReadState::Builder::disownSubarrayPartitioner() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::SubarrayPartitioner>:: + disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ConditionClause::Reader::hasFieldName() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ConditionClause::Builder::hasFieldName() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader ConditionClause::Reader::getFieldName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ConditionClause::Reader::getFieldName() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ConditionClause::Builder::getFieldName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ConditionClause::Builder::getFieldName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void ConditionClause::Builder::setFieldName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void ConditionClause::Builder::setFieldName( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder ConditionClause::Builder::initFieldName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder ConditionClause::Builder::initFieldName( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void ConditionClause::Builder::adoptFieldName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> ConditionClause::Builder::disownFieldName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +ConditionClause::Builder::disownFieldName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ConditionClause::Reader::hasValue() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool ConditionClause::Builder::hasValue() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Data::Reader ConditionClause::Reader::getValue() const { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Data::Reader ConditionClause::Reader::getValue() const { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Data::Builder ConditionClause::Builder::getValue() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Data::Builder ConditionClause::Builder::getValue() { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void ConditionClause::Builder::setValue( ::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void ConditionClause::Builder::setValue(::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Data>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::capnp::Data::Builder ConditionClause::Builder::initValue(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); +inline ::capnp::Data::Builder ConditionClause::Builder::initValue( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Data>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void ConditionClause::Builder::adoptValue( - ::capnp::Orphan< ::capnp::Data>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Data>&& value) { + ::capnp::_::PointerHelpers<::capnp::Data>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Data> ConditionClause::Builder::disownValue() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Data> ConditionClause::Builder::disownValue() { + return ::capnp::_::PointerHelpers<::capnp::Data>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool ConditionClause::Reader::hasOp() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool ConditionClause::Builder::hasOp() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader ConditionClause::Reader::getOp() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ConditionClause::Reader::getOp() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ConditionClause::Builder::getOp() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ConditionClause::Builder::getOp() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void ConditionClause::Builder::setOp( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void ConditionClause::Builder::setOp(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder ConditionClause::Builder::initOp(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder ConditionClause::Builder::initOp( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void ConditionClause::Builder::adoptOp( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> ConditionClause::Builder::disownOp() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> ConditionClause::Builder::disownOp() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool ConditionClause::Reader::getUseEnumeration() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool ConditionClause::Builder::getUseEnumeration() { - return _builder.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void ConditionClause::Builder::setUseEnumeration(bool value) { - _builder.setDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool ASTNode::Reader::getIsExpression() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool ASTNode::Builder::getIsExpression() { - return _builder.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void ASTNode::Builder::setIsExpression(bool value) { - _builder.setDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool ASTNode::Reader::hasFieldName() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ASTNode::Builder::hasFieldName() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader ASTNode::Reader::getFieldName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ASTNode::Reader::getFieldName() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ASTNode::Builder::getFieldName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ASTNode::Builder::getFieldName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void ASTNode::Builder::setFieldName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void ASTNode::Builder::setFieldName(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder ASTNode::Builder::initFieldName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder ASTNode::Builder::initFieldName( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void ASTNode::Builder::adoptFieldName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> ASTNode::Builder::disownFieldName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> ASTNode::Builder::disownFieldName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ASTNode::Reader::hasValue() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool ASTNode::Builder::hasValue() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Data::Reader ASTNode::Reader::getValue() const { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Data::Reader ASTNode::Reader::getValue() const { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Data::Builder ASTNode::Builder::getValue() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Data::Builder ASTNode::Builder::getValue() { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void ASTNode::Builder::setValue( ::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void ASTNode::Builder::setValue(::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Data>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::capnp::Data::Builder ASTNode::Builder::initValue(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); +inline ::capnp::Data::Builder ASTNode::Builder::initValue(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Data>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void ASTNode::Builder::adoptValue( - ::capnp::Orphan< ::capnp::Data>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Data>&& value) { + ::capnp::_::PointerHelpers<::capnp::Data>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Data> ASTNode::Builder::disownValue() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Data> ASTNode::Builder::disownValue() { + return ::capnp::_::PointerHelpers<::capnp::Data>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool ASTNode::Reader::hasOp() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool ASTNode::Builder::hasOp() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader ASTNode::Reader::getOp() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ASTNode::Reader::getOp() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ASTNode::Builder::getOp() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ASTNode::Builder::getOp() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void ASTNode::Builder::setOp( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void ASTNode::Builder::setOp(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder ASTNode::Builder::initOp(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder ASTNode::Builder::initOp(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } -inline void ASTNode::Builder::adoptOp( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); +inline void ASTNode::Builder::adoptOp(::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> ASTNode::Builder::disownOp() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> ASTNode::Builder::disownOp() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool ASTNode::Reader::hasChildren() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool ASTNode::Builder::hasChildren() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>::Reader ASTNode::Reader::getChildren() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>::Builder ASTNode::Builder::getChildren() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline void ASTNode::Builder::setChildren( ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>::Builder ASTNode::Builder::initChildren(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>::Reader +ASTNode::Reader::getChildren() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<3>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>::Builder +ASTNode::Builder::getChildren() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<3>() * + ::capnp::POINTERS)); +} +inline void ASTNode::Builder::setChildren( + ::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>::Builder +ASTNode::Builder::initChildren(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + size); } inline void ASTNode::Builder::adoptChildren( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>> ASTNode::Builder::disownChildren() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ASTNode, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>> +ASTNode::Builder::disownChildren() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ASTNode, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<3>() * + ::capnp::POINTERS)); } inline bool ASTNode::Reader::hasCombinationOp() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool ASTNode::Builder::hasCombinationOp() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader ASTNode::Reader::getCombinationOp() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ASTNode::Reader::getCombinationOp() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ASTNode::Builder::getCombinationOp() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ASTNode::Builder::getCombinationOp() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline void ASTNode::Builder::setCombinationOp( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); +inline void ASTNode::Builder::setCombinationOp(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder ASTNode::Builder::initCombinationOp(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder ASTNode::Builder::initCombinationOp( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + size); } inline void ASTNode::Builder::adoptCombinationOp( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> ASTNode::Builder::disownCombinationOp() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> ASTNode::Builder::disownCombinationOp() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool ASTNode::Reader::getUseEnumeration() const { - return _reader.getDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline bool ASTNode::Builder::getUseEnumeration() { - return _builder.getDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline void ASTNode::Builder::setUseEnumeration(bool value) { - _builder.setDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool ASTNode::Reader::hasOffsets() const { - return !_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } inline bool ASTNode::Builder::hasOffsets() { - return !_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Data::Reader ASTNode::Reader::getOffsets() const { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Data::Reader ASTNode::Reader::getOffsets() const { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline ::capnp::Data::Builder ASTNode::Builder::getOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Data::Builder ASTNode::Builder::getOffsets() { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline void ASTNode::Builder::setOffsets( ::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), value); +inline void ASTNode::Builder::setOffsets(::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Data>::set( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + value); } -inline ::capnp::Data::Builder ASTNode::Builder::initOffsets(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), size); +inline ::capnp::Data::Builder ASTNode::Builder::initOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Data>::init( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + size); } inline void ASTNode::Builder::adoptOffsets( - ::capnp::Orphan< ::capnp::Data>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Data>&& value) { + ::capnp::_::PointerHelpers<::capnp::Data>::adopt( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Data> ASTNode::Builder::disownOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Data> ASTNode::Builder::disownOffsets() { + return ::capnp::_::PointerHelpers<::capnp::Data>::disown( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool Condition::Reader::hasClauses() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool Condition::Builder::hasClauses() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>::Reader Condition::Reader::getClauses() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>::Builder Condition::Builder::getClauses() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void Condition::Builder::setClauses( ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>::Builder Condition::Builder::initClauses(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>::Reader +Condition::Reader::getClauses() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>::Builder +Condition::Builder::getClauses() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void Condition::Builder::setClauses( + ::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>::Builder +Condition::Builder::initClauses(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void Condition::Builder::adoptClauses( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>> Condition::Builder::disownClauses() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ConditionClause, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>> +Condition::Builder::disownClauses() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ConditionClause, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } inline bool Condition::Reader::hasClauseCombinationOps() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool Condition::Builder::hasClauseCombinationOps() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader Condition::Reader::getClauseCombinationOps() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder Condition::Builder::getClauseCombinationOps() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void Condition::Builder::setClauseCombinationOps( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline void Condition::Builder::setClauseCombinationOps(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder Condition::Builder::initClauseCombinationOps(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +Condition::Reader::getClauseCombinationOps() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +Condition::Builder::getClauseCombinationOps() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void Condition::Builder::setClauseCombinationOps( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline void Condition::Builder::setClauseCombinationOps( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +Condition::Builder::initClauseCombinationOps(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void Condition::Builder::adoptClauseCombinationOps( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> Condition::Builder::disownClauseCombinationOps() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +Condition::Builder::disownClauseCombinationOps() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Condition::Reader::hasTree() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool Condition::Builder::hasTree() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::ASTNode::Reader Condition::Reader::getTree() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ASTNode>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ASTNode::Reader +Condition::Reader::getTree() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ASTNode>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ASTNode::Builder Condition::Builder::getTree() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ASTNode>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ASTNode::Builder +Condition::Builder::getTree() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ASTNode>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ASTNode::Pipeline Condition::Pipeline::getTree() { - return ::tiledb::sm::serialization::capnp::ASTNode::Pipeline(_typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::ASTNode::Pipeline +Condition::Pipeline::getTree() { + return ::tiledb::sm::serialization::capnp::ASTNode::Pipeline( + _typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void Condition::Builder::setTree( ::tiledb::sm::serialization::capnp::ASTNode::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ASTNode>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void Condition::Builder::setTree( + ::tiledb::sm::serialization::capnp::ASTNode::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ASTNode>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::ASTNode::Builder Condition::Builder::initTree() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ASTNode>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ASTNode::Builder +Condition::Builder::initTree() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ASTNode>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void Condition::Builder::adoptTree( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ASTNode>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ASTNode>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ASTNode>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ASTNode>:: + adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ASTNode> Condition::Builder::disownTree() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ASTNode>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ASTNode> +Condition::Builder::disownTree() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ASTNode>::disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool QueryReader::Reader::hasLayout() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool QueryReader::Builder::hasLayout() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader QueryReader::Reader::getLayout() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader QueryReader::Reader::getLayout() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder QueryReader::Builder::getLayout() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder QueryReader::Builder::getLayout() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void QueryReader::Builder::setLayout( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void QueryReader::Builder::setLayout(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder QueryReader::Builder::initLayout(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder QueryReader::Builder::initLayout( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void QueryReader::Builder::adoptLayout( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> QueryReader::Builder::disownLayout() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> QueryReader::Builder::disownLayout() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool QueryReader::Reader::hasSubarray() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool QueryReader::Builder::hasSubarray() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Subarray::Reader QueryReader::Reader::getSubarray() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Reader +QueryReader::Reader::getSubarray() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder QueryReader::Builder::getSubarray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder +QueryReader::Builder::getSubarray() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline QueryReader::Pipeline::getSubarray() { - return ::tiledb::sm::serialization::capnp::Subarray::Pipeline(_typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline +QueryReader::Pipeline::getSubarray() { + return ::tiledb::sm::serialization::capnp::Subarray::Pipeline( + _typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void QueryReader::Builder::setSubarray( ::tiledb::sm::serialization::capnp::Subarray::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void QueryReader::Builder::setSubarray( + ::tiledb::sm::serialization::capnp::Subarray::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder QueryReader::Builder::initSubarray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder +QueryReader::Builder::initSubarray() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void QueryReader::Builder::adoptSubarray( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> QueryReader::Builder::disownSubarray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> +QueryReader::Builder::disownSubarray() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool QueryReader::Reader::hasReadState() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool QueryReader::Builder::hasReadState() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::ReadState::Reader QueryReader::Reader::getReadState() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadState>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReadState::Reader +QueryReader::Reader::getReadState() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ReadState>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ReadState::Builder QueryReader::Builder::getReadState() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadState>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReadState::Builder +QueryReader::Builder::getReadState() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ReadState>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ReadState::Pipeline QueryReader::Pipeline::getReadState() { - return ::tiledb::sm::serialization::capnp::ReadState::Pipeline(_typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::ReadState::Pipeline +QueryReader::Pipeline::getReadState() { + return ::tiledb::sm::serialization::capnp::ReadState::Pipeline( + _typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void QueryReader::Builder::setReadState( ::tiledb::sm::serialization::capnp::ReadState::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadState>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void QueryReader::Builder::setReadState( + ::tiledb::sm::serialization::capnp::ReadState::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ReadState>:: + set(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::ReadState::Builder QueryReader::Builder::initReadState() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadState>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReadState::Builder +QueryReader::Builder::initReadState() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ReadState>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void QueryReader::Builder::adoptReadState( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReadState>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadState>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReadState>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ReadState>:: + adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReadState> QueryReader::Builder::disownReadState() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadState>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReadState> +QueryReader::Builder::disownReadState() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ReadState>::disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool QueryReader::Reader::hasCondition() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool QueryReader::Builder::hasCondition() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Condition::Reader QueryReader::Reader::getCondition() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Reader +QueryReader::Reader::getCondition() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Condition::Builder QueryReader::Builder::getCondition() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Builder +QueryReader::Builder::getCondition() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Condition::Pipeline QueryReader::Pipeline::getCondition() { - return ::tiledb::sm::serialization::capnp::Condition::Pipeline(_typeless.getPointerField(3)); +inline ::tiledb::sm::serialization::capnp::Condition::Pipeline +QueryReader::Pipeline::getCondition() { + return ::tiledb::sm::serialization::capnp::Condition::Pipeline( + _typeless.getPointerField(3)); } #endif // !CAPNP_LITE -inline void QueryReader::Builder::setCondition( ::tiledb::sm::serialization::capnp::Condition::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); +inline void QueryReader::Builder::setCondition( + ::tiledb::sm::serialization::capnp::Condition::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Condition>:: + set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Condition::Builder QueryReader::Builder::initCondition() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Builder +QueryReader::Builder::initCondition() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void QueryReader::Builder::adoptCondition( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Condition>:: + adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition> QueryReader::Builder::disownCondition() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition> +QueryReader::Builder::disownCondition() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool QueryReader::Reader::hasStats() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool QueryReader::Builder::hasStats() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Stats::Reader QueryReader::Reader::getStats() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Reader +QueryReader::Reader::getStats() const { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + get(_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder QueryReader::Builder::getStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder +QueryReader::Builder::getStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + get(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Stats::Pipeline QueryReader::Pipeline::getStats() { - return ::tiledb::sm::serialization::capnp::Stats::Pipeline(_typeless.getPointerField(4)); +inline ::tiledb::sm::serialization::capnp::Stats::Pipeline +QueryReader::Pipeline::getStats() { + return ::tiledb::sm::serialization::capnp::Stats::Pipeline( + _typeless.getPointerField(4)); } #endif // !CAPNP_LITE -inline void QueryReader::Builder::setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); +inline void QueryReader::Builder::setStats( + ::tiledb::sm::serialization::capnp::Stats::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder QueryReader::Builder::initStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder +QueryReader::Builder::initStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + init(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline void QueryReader::Builder::adoptStats( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> QueryReader::Builder::disownStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> +QueryReader::Builder::disownStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + disown( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool QueryReader::Reader::getDimLabelIncreasing() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool QueryReader::Builder::getDimLabelIncreasing() { - return _builder.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void QueryReader::Builder::setDimLabelIncreasing(bool value) { - _builder.setDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool Delete::Reader::hasCondition() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool Delete::Builder::hasCondition() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Condition::Reader Delete::Reader::getCondition() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Reader +Delete::Reader::getCondition() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Condition::Builder Delete::Builder::getCondition() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Builder +Delete::Builder::getCondition() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Condition::Pipeline Delete::Pipeline::getCondition() { - return ::tiledb::sm::serialization::capnp::Condition::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Condition::Pipeline +Delete::Pipeline::getCondition() { + return ::tiledb::sm::serialization::capnp::Condition::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void Delete::Builder::setCondition( ::tiledb::sm::serialization::capnp::Condition::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void Delete::Builder::setCondition( + ::tiledb::sm::serialization::capnp::Condition::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Condition>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Condition::Builder Delete::Builder::initCondition() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Builder +Delete::Builder::initCondition() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void Delete::Builder::adoptCondition( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Condition>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition> Delete::Builder::disownCondition() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition> +Delete::Builder::disownCondition() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Delete::Reader::hasStats() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool Delete::Builder::hasStats() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Stats::Reader Delete::Reader::getStats() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Reader +Delete::Reader::getStats() const { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + get(_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder Delete::Builder::getStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder +Delete::Builder::getStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + get(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Stats::Pipeline Delete::Pipeline::getStats() { - return ::tiledb::sm::serialization::capnp::Stats::Pipeline(_typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::Stats::Pipeline +Delete::Pipeline::getStats() { + return ::tiledb::sm::serialization::capnp::Stats::Pipeline( + _typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void Delete::Builder::setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void Delete::Builder::setStats( + ::tiledb::sm::serialization::capnp::Stats::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder Delete::Builder::initStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder +Delete::Builder::initStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void Delete::Builder::adoptStats( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> Delete::Builder::disownStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> +Delete::Builder::disownStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::uint32_t ResultCellSlab::Reader::getFragIdx() const { - return _reader.getDataField< ::uint32_t>( +inline ::uint32_t ResultCellSlab::Reader::getFragIdx() const { + return _reader.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint32_t ResultCellSlab::Builder::getFragIdx() { - return _builder.getDataField< ::uint32_t>( +inline ::uint32_t ResultCellSlab::Builder::getFragIdx() { + return _builder.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ResultCellSlab::Builder::setFragIdx( ::uint32_t value) { - _builder.setDataField< ::uint32_t>( +inline void ResultCellSlab::Builder::setFragIdx(::uint32_t value) { + _builder.setDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t ResultCellSlab::Reader::getTileIdx() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t ResultCellSlab::Reader::getTileIdx() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t ResultCellSlab::Builder::getTileIdx() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t ResultCellSlab::Builder::getTileIdx() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void ResultCellSlab::Builder::setTileIdx( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void ResultCellSlab::Builder::setTileIdx(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t ResultCellSlab::Reader::getStart() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t ResultCellSlab::Reader::getStart() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t ResultCellSlab::Builder::getStart() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t ResultCellSlab::Builder::getStart() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void ResultCellSlab::Builder::setStart( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void ResultCellSlab::Builder::setStart(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t ResultCellSlab::Reader::getLength() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t ResultCellSlab::Reader::getLength() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS); } -inline ::uint64_t ResultCellSlab::Builder::getLength() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t ResultCellSlab::Builder::getLength() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS); } -inline void ResultCellSlab::Builder::setLength( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void ResultCellSlab::Builder::setLength(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t FragmentIndex::Reader::getTileIdx() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t FragmentIndex::Reader::getTileIdx() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t FragmentIndex::Builder::getTileIdx() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t FragmentIndex::Builder::getTileIdx() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void FragmentIndex::Builder::setTileIdx( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void FragmentIndex::Builder::setTileIdx(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t FragmentIndex::Reader::getCellIdx() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t FragmentIndex::Reader::getCellIdx() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t FragmentIndex::Builder::getCellIdx() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t FragmentIndex::Builder::getCellIdx() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void FragmentIndex::Builder::setCellIdx( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void FragmentIndex::Builder::setCellIdx(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool ReadStateIndex::Reader::hasResultCellSlab() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ReadStateIndex::Builder::hasResultCellSlab() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>::Reader ReadStateIndex::Reader::getResultCellSlab() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>::Builder ReadStateIndex::Builder::getResultCellSlab() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void ReadStateIndex::Builder::setResultCellSlab( ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>::Builder ReadStateIndex::Builder::initResultCellSlab(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>::Reader +ReadStateIndex::Reader::getResultCellSlab() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>::Builder +ReadStateIndex::Builder::getResultCellSlab() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void ReadStateIndex::Builder::setResultCellSlab( + ::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>::Builder +ReadStateIndex::Builder::initResultCellSlab(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void ReadStateIndex::Builder::adoptResultCellSlab( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>> ReadStateIndex::Builder::disownResultCellSlab() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ResultCellSlab, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>> +ReadStateIndex::Builder::disownResultCellSlab() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultCellSlab, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } inline bool ReadStateIndex::Reader::hasFragTileIdx() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool ReadStateIndex::Builder::hasFragTileIdx() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>::Reader ReadStateIndex::Reader::getFragTileIdx() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>::Builder ReadStateIndex::Builder::getFragTileIdx() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void ReadStateIndex::Builder::setFragTileIdx( ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>::Builder ReadStateIndex::Builder::initFragTileIdx(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>::Reader +ReadStateIndex::Reader::getFragTileIdx() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>::Builder +ReadStateIndex::Builder::getFragTileIdx() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline void ReadStateIndex::Builder::setFragTileIdx( + ::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>::Builder +ReadStateIndex::Builder::initFragTileIdx(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void ReadStateIndex::Builder::adoptFragTileIdx( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>> ReadStateIndex::Builder::disownFragTileIdx() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::FragmentIndex, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>> +ReadStateIndex::Builder::disownFragTileIdx() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::FragmentIndex, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); } inline bool ReadStateIndex::Reader::getDoneAddingResultTiles() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool ReadStateIndex::Builder::getDoneAddingResultTiles() { - return _builder.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void ReadStateIndex::Builder::setDoneAddingResultTiles(bool value) { - _builder.setDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t PreprocessTileOrder::Reader::getCursor() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t PreprocessTileOrder::Reader::getCursor() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t PreprocessTileOrder::Builder::getCursor() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t PreprocessTileOrder::Builder::getCursor() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void PreprocessTileOrder::Builder::setCursor( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void PreprocessTileOrder::Builder::setCursor(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool ReaderIndex::Reader::hasLayout() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ReaderIndex::Builder::hasLayout() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader ReaderIndex::Reader::getLayout() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader ReaderIndex::Reader::getLayout() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder ReaderIndex::Builder::getLayout() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder ReaderIndex::Builder::getLayout() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void ReaderIndex::Builder::setLayout( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void ReaderIndex::Builder::setLayout(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder ReaderIndex::Builder::initLayout(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder ReaderIndex::Builder::initLayout( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void ReaderIndex::Builder::adoptLayout( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> ReaderIndex::Builder::disownLayout() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> ReaderIndex::Builder::disownLayout() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ReaderIndex::Reader::hasSubarray() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool ReaderIndex::Builder::hasSubarray() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Subarray::Reader ReaderIndex::Reader::getSubarray() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Reader +ReaderIndex::Reader::getSubarray() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder ReaderIndex::Builder::getSubarray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder +ReaderIndex::Builder::getSubarray() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline ReaderIndex::Pipeline::getSubarray() { - return ::tiledb::sm::serialization::capnp::Subarray::Pipeline(_typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::Subarray::Pipeline +ReaderIndex::Pipeline::getSubarray() { + return ::tiledb::sm::serialization::capnp::Subarray::Pipeline( + _typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void ReaderIndex::Builder::setSubarray( ::tiledb::sm::serialization::capnp::Subarray::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void ReaderIndex::Builder::setSubarray( + ::tiledb::sm::serialization::capnp::Subarray::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Subarray::Builder ReaderIndex::Builder::initSubarray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Subarray::Builder +ReaderIndex::Builder::initSubarray() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void ReaderIndex::Builder::adoptSubarray( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Subarray> ReaderIndex::Builder::disownSubarray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Subarray>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Subarray> +ReaderIndex::Builder::disownSubarray() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Subarray>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool ReaderIndex::Reader::hasReadState() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool ReaderIndex::Builder::hasReadState() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Reader ReaderIndex::Reader::getReadState() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadStateIndex>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Reader +ReaderIndex::Reader::getReadState() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ReadStateIndex>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Builder ReaderIndex::Builder::getReadState() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadStateIndex>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Builder +ReaderIndex::Builder::getReadState() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ReadStateIndex>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Pipeline ReaderIndex::Pipeline::getReadState() { - return ::tiledb::sm::serialization::capnp::ReadStateIndex::Pipeline(_typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Pipeline +ReaderIndex::Pipeline::getReadState() { + return ::tiledb::sm::serialization::capnp::ReadStateIndex::Pipeline( + _typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void ReaderIndex::Builder::setReadState( ::tiledb::sm::serialization::capnp::ReadStateIndex::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadStateIndex>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void ReaderIndex::Builder::setReadState( + ::tiledb::sm::serialization::capnp::ReadStateIndex::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ReadStateIndex>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Builder ReaderIndex::Builder::initReadState() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadStateIndex>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReadStateIndex::Builder +ReaderIndex::Builder::initReadState() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ReadStateIndex>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void ReaderIndex::Builder::adoptReadState( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReadStateIndex>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadStateIndex>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReadStateIndex>&& + value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ReadStateIndex>::adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReadStateIndex> ReaderIndex::Builder::disownReadState() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReadStateIndex>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReadStateIndex> +ReaderIndex::Builder::disownReadState() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::ReadStateIndex>:: + disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool ReaderIndex::Reader::hasCondition() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool ReaderIndex::Builder::hasCondition() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Condition::Reader ReaderIndex::Reader::getCondition() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Reader +ReaderIndex::Reader::getCondition() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Condition::Builder ReaderIndex::Builder::getCondition() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Builder +ReaderIndex::Builder::getCondition() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Condition::Pipeline ReaderIndex::Pipeline::getCondition() { - return ::tiledb::sm::serialization::capnp::Condition::Pipeline(_typeless.getPointerField(3)); +inline ::tiledb::sm::serialization::capnp::Condition::Pipeline +ReaderIndex::Pipeline::getCondition() { + return ::tiledb::sm::serialization::capnp::Condition::Pipeline( + _typeless.getPointerField(3)); } #endif // !CAPNP_LITE -inline void ReaderIndex::Builder::setCondition( ::tiledb::sm::serialization::capnp::Condition::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); +inline void ReaderIndex::Builder::setCondition( + ::tiledb::sm::serialization::capnp::Condition::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Condition>:: + set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Condition::Builder ReaderIndex::Builder::initCondition() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Condition::Builder +ReaderIndex::Builder::initCondition() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void ReaderIndex::Builder::adoptCondition( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Condition>:: + adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Condition> ReaderIndex::Builder::disownCondition() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Condition>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Condition> +ReaderIndex::Builder::disownCondition() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Condition>::disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool ReaderIndex::Reader::hasStats() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool ReaderIndex::Builder::hasStats() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Stats::Reader ReaderIndex::Reader::getStats() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Reader +ReaderIndex::Reader::getStats() const { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + get(_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder ReaderIndex::Builder::getStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder +ReaderIndex::Builder::getStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + get(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Stats::Pipeline ReaderIndex::Pipeline::getStats() { - return ::tiledb::sm::serialization::capnp::Stats::Pipeline(_typeless.getPointerField(4)); +inline ::tiledb::sm::serialization::capnp::Stats::Pipeline +ReaderIndex::Pipeline::getStats() { + return ::tiledb::sm::serialization::capnp::Stats::Pipeline( + _typeless.getPointerField(4)); } #endif // !CAPNP_LITE -inline void ReaderIndex::Builder::setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); +inline void ReaderIndex::Builder::setStats( + ::tiledb::sm::serialization::capnp::Stats::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder ReaderIndex::Builder::initStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder +ReaderIndex::Builder::initStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + init(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline void ReaderIndex::Builder::adoptStats( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> ReaderIndex::Builder::disownStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> +ReaderIndex::Builder::disownStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + disown( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool ReaderIndex::Reader::hasPreprocess() const { - return !_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } inline bool ReaderIndex::Builder::hasPreprocess() { - return !_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Reader ReaderIndex::Reader::getPreprocess() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::PreprocessTileOrder>::get(_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Reader +ReaderIndex::Reader::getPreprocess() const { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::PreprocessTileOrder>:: + get(_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Builder ReaderIndex::Builder::getPreprocess() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::PreprocessTileOrder>::get(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Builder +ReaderIndex::Builder::getPreprocess() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::PreprocessTileOrder>:: + get(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Pipeline ReaderIndex::Pipeline::getPreprocess() { - return ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Pipeline(_typeless.getPointerField(5)); +inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Pipeline +ReaderIndex::Pipeline::getPreprocess() { + return ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Pipeline( + _typeless.getPointerField(5)); } #endif // !CAPNP_LITE -inline void ReaderIndex::Builder::setPreprocess( ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::PreprocessTileOrder>::set(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), value); +inline void ReaderIndex::Builder::setPreprocess( + ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Reader value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::PreprocessTileOrder>:: + set(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Builder ReaderIndex::Builder::initPreprocess() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::PreprocessTileOrder>::init(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Builder +ReaderIndex::Builder::initPreprocess() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::PreprocessTileOrder>:: + init(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } inline void ReaderIndex::Builder::adoptPreprocess( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::PreprocessTileOrder>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::PreprocessTileOrder>::adopt(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::PreprocessTileOrder> ReaderIndex::Builder::disownPreprocess() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::PreprocessTileOrder>::disown(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::PreprocessTileOrder>&& + value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::PreprocessTileOrder>:: + adopt( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::PreprocessTileOrder> +ReaderIndex::Builder::disownPreprocess() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::PreprocessTileOrder>:: + disown( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasAttributeBufferHeaders() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool Query::Builder::hasAttributeBufferHeaders() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>::Reader Query::Reader::getAttributeBufferHeaders() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>::Builder Query::Builder::getAttributeBufferHeaders() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void Query::Builder::setAttributeBufferHeaders( ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>::Builder Query::Builder::initAttributeBufferHeaders(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>::Reader +Query::Reader::getAttributeBufferHeaders() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>::Builder +Query::Builder::getAttributeBufferHeaders() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void Query::Builder::setAttributeBufferHeaders( + ::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>::Builder +Query::Builder::initAttributeBufferHeaders(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void Query::Builder::adoptAttributeBufferHeaders( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>> Query::Builder::disownAttributeBufferHeaders() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::AttributeBufferHeader, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>> +Query::Builder::disownAttributeBufferHeaders() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::AttributeBufferHeader, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } inline bool Query::Reader::hasLayout() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool Query::Builder::hasLayout() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Query::Reader::getLayout() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Query::Reader::getLayout() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Query::Builder::getLayout() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Query::Builder::getLayout() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void Query::Builder::setLayout( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void Query::Builder::setLayout(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Query::Builder::initLayout(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Query::Builder::initLayout(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void Query::Builder::adoptLayout( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Query::Builder::disownLayout() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Query::Builder::disownLayout() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasStatus() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool Query::Builder::hasStatus() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Query::Reader::getStatus() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Query::Reader::getStatus() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Query::Builder::getStatus() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Query::Builder::getStatus() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void Query::Builder::setStatus( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void Query::Builder::setStatus(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Query::Builder::initStatus(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Query::Builder::initStatus(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void Query::Builder::adoptStatus( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Query::Builder::disownStatus() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Query::Builder::disownStatus() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasType() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool Query::Builder::hasType() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Query::Reader::getType() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Query::Reader::getType() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Query::Builder::getType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Query::Builder::getType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline void Query::Builder::setType( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); +inline void Query::Builder::setType(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Query::Builder::initType(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Query::Builder::initType(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + size); } -inline void Query::Builder::adoptType( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); +inline void Query::Builder::adoptType(::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Query::Builder::disownType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Query::Builder::disownType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasWriter() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool Query::Builder::hasWriter() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Writer::Reader Query::Reader::getWriter() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Writer>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Writer::Reader +Query::Reader::getWriter() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Writer>::get( + _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Writer::Builder Query::Builder::getWriter() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Writer>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Writer::Builder +Query::Builder::getWriter() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Writer>::get( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Writer::Pipeline Query::Pipeline::getWriter() { - return ::tiledb::sm::serialization::capnp::Writer::Pipeline(_typeless.getPointerField(4)); +inline ::tiledb::sm::serialization::capnp::Writer::Pipeline +Query::Pipeline::getWriter() { + return ::tiledb::sm::serialization::capnp::Writer::Pipeline( + _typeless.getPointerField(4)); } #endif // !CAPNP_LITE -inline void Query::Builder::setWriter( ::tiledb::sm::serialization::capnp::Writer::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Writer>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); +inline void Query::Builder::setWriter( + ::tiledb::sm::serialization::capnp::Writer::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Writer>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Writer::Builder Query::Builder::initWriter() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Writer>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Writer::Builder +Query::Builder::initWriter() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Writer>::init( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptWriter( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Writer>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Writer>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Writer>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Writer>::adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Writer> Query::Builder::disownWriter() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Writer>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Writer> +Query::Builder::disownWriter() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Writer>::disown( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasReader() const { - return !_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } inline bool Query::Builder::hasReader() { - return !_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Reader Query::Reader::getReader() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::get(_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Reader +Query::Reader::getReader() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::get( + _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Builder Query::Builder::getReader() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::get(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Builder +Query::Builder::getReader() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::get( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline Query::Pipeline::getReader() { - return ::tiledb::sm::serialization::capnp::QueryReader::Pipeline(_typeless.getPointerField(5)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline +Query::Pipeline::getReader() { + return ::tiledb::sm::serialization::capnp::QueryReader::Pipeline( + _typeless.getPointerField(5)); } #endif // !CAPNP_LITE -inline void Query::Builder::setReader( ::tiledb::sm::serialization::capnp::QueryReader::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::set(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), value); +inline void Query::Builder::setReader( + ::tiledb::sm::serialization::capnp::QueryReader::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>:: + set(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Builder Query::Builder::initReader() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::init(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Builder +Query::Builder::initReader() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::init( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptReader( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::adopt(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>:: + adopt( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader> Query::Builder::disownReader() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::disown(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader> +Query::Builder::disownReader() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::disown( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasArray() const { - return !_reader.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) + .isNull(); } inline bool Query::Builder::hasArray() { - return !_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Array::Reader Query::Reader::getArray() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Array>::get(_reader.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Array::Reader +Query::Reader::getArray() const { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Array>:: + get(_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Array::Builder Query::Builder::getArray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Array>::get(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Array::Builder +Query::Builder::getArray() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Array>:: + get(_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Array::Pipeline Query::Pipeline::getArray() { - return ::tiledb::sm::serialization::capnp::Array::Pipeline(_typeless.getPointerField(6)); +inline ::tiledb::sm::serialization::capnp::Array::Pipeline +Query::Pipeline::getArray() { + return ::tiledb::sm::serialization::capnp::Array::Pipeline( + _typeless.getPointerField(6)); } #endif // !CAPNP_LITE -inline void Query::Builder::setArray( ::tiledb::sm::serialization::capnp::Array::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Array>::set(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), value); +inline void Query::Builder::setArray( + ::tiledb::sm::serialization::capnp::Array::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Array>::set( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Array::Builder Query::Builder::initArray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Array>::init(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Array::Builder +Query::Builder::initArray() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Array>:: + init(_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptArray( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Array>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Array>::adopt(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Array>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Array>::adopt( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Array> Query::Builder::disownArray() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Array>::disown(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Array> +Query::Builder::disownArray() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Array>:: + disown( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); } -inline ::uint64_t Query::Reader::getTotalFixedLengthBufferBytes() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t Query::Reader::getTotalFixedLengthBufferBytes() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t Query::Builder::getTotalFixedLengthBufferBytes() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t Query::Builder::getTotalFixedLengthBufferBytes() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void Query::Builder::setTotalFixedLengthBufferBytes( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void Query::Builder::setTotalFixedLengthBufferBytes(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t Query::Reader::getTotalVarLenBufferBytes() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t Query::Reader::getTotalVarLenBufferBytes() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t Query::Builder::getTotalVarLenBufferBytes() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t Query::Builder::getTotalVarLenBufferBytes() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void Query::Builder::setTotalVarLenBufferBytes( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void Query::Builder::setTotalVarLenBufferBytes(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t Query::Reader::getTotalValidityBufferBytes() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t Query::Reader::getTotalValidityBufferBytes() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t Query::Builder::getTotalValidityBufferBytes() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t Query::Builder::getTotalValidityBufferBytes() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void Query::Builder::setTotalValidityBufferBytes( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void Query::Builder::setTotalValidityBufferBytes(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool Query::Reader::hasVarOffsetsMode() const { - return !_reader.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) + .isNull(); } inline bool Query::Builder::hasVarOffsetsMode() { - return !_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Query::Reader::getVarOffsetsMode() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Query::Reader::getVarOffsetsMode() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Query::Builder::getVarOffsetsMode() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Query::Builder::getVarOffsetsMode() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); } -inline void Query::Builder::setVarOffsetsMode( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), value); +inline void Query::Builder::setVarOffsetsMode(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Query::Builder::initVarOffsetsMode(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Query::Builder::initVarOffsetsMode( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + size); } inline void Query::Builder::adoptVarOffsetsMode( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Query::Builder::disownVarOffsetsMode() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Query::Builder::disownVarOffsetsMode() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); } inline bool Query::Reader::getVarOffsetsAddExtraElement() const { @@ -20030,714 +26530,1029 @@ inline void Query::Builder::setVarOffsetsAddExtraElement(bool value) { ::capnp::bounded<192>() * ::capnp::ELEMENTS, value); } -inline ::int32_t Query::Reader::getVarOffsetsBitsize() const { - return _reader.getDataField< ::int32_t>( +inline ::int32_t Query::Reader::getVarOffsetsBitsize() const { + return _reader.getDataField<::int32_t>( ::capnp::bounded<7>() * ::capnp::ELEMENTS); } -inline ::int32_t Query::Builder::getVarOffsetsBitsize() { - return _builder.getDataField< ::int32_t>( +inline ::int32_t Query::Builder::getVarOffsetsBitsize() { + return _builder.getDataField<::int32_t>( ::capnp::bounded<7>() * ::capnp::ELEMENTS); } -inline void Query::Builder::setVarOffsetsBitsize( ::int32_t value) { - _builder.setDataField< ::int32_t>( +inline void Query::Builder::setVarOffsetsBitsize(::int32_t value) { + _builder.setDataField<::int32_t>( ::capnp::bounded<7>() * ::capnp::ELEMENTS, value); } inline bool Query::Reader::hasConfig() const { - return !_reader.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) + .isNull(); } inline bool Query::Builder::hasConfig() { - return !_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader Query::Reader::getConfig() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader +Query::Reader::getConfig() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder Query::Builder::getConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +Query::Builder::getConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline Query::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(8)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline +Query::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline( + _typeless.getPointerField(8)); } #endif // !CAPNP_LITE -inline void Query::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), value); +inline void Query::Builder::setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder Query::Builder::initConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +Query::Builder::initConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptConfig( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> Query::Builder::disownConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> +Query::Builder::disownConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasStats() const { - return !_reader.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) + .isNull(); } inline bool Query::Builder::hasStats() { - return !_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Stats::Reader Query::Reader::getStats() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_reader.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Reader +Query::Reader::getStats() const { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + get(_reader.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder Query::Builder::getStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::get(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder +Query::Builder::getStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + get(_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Stats::Pipeline Query::Pipeline::getStats() { - return ::tiledb::sm::serialization::capnp::Stats::Pipeline(_typeless.getPointerField(9)); +inline ::tiledb::sm::serialization::capnp::Stats::Pipeline +Query::Pipeline::getStats() { + return ::tiledb::sm::serialization::capnp::Stats::Pipeline( + _typeless.getPointerField(9)); } #endif // !CAPNP_LITE -inline void Query::Builder::setStats( ::tiledb::sm::serialization::capnp::Stats::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::set(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS), value); +inline void Query::Builder::setStats( + ::tiledb::sm::serialization::capnp::Stats::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::set( + _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Stats::Builder Query::Builder::initStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::init(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Stats::Builder +Query::Builder::initStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + init(_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptStats( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::adopt(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>::adopt( + _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Stats> Query::Builder::disownStats() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Stats>::disown(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> +Query::Builder::disownStats() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Stats>:: + disown( + _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasReaderIndex() const { - return !_reader.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS) + .isNull(); } inline bool Query::Builder::hasReaderIndex() { - return !_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::ReaderIndex::Reader Query::Reader::getReaderIndex() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReaderIndex>::get(_reader.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReaderIndex::Reader +Query::Reader::getReaderIndex() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ReaderIndex>::get( + _reader.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ReaderIndex::Builder Query::Builder::getReaderIndex() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReaderIndex>::get(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReaderIndex::Builder +Query::Builder::getReaderIndex() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ReaderIndex>::get( + _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ReaderIndex::Pipeline Query::Pipeline::getReaderIndex() { - return ::tiledb::sm::serialization::capnp::ReaderIndex::Pipeline(_typeless.getPointerField(10)); +inline ::tiledb::sm::serialization::capnp::ReaderIndex::Pipeline +Query::Pipeline::getReaderIndex() { + return ::tiledb::sm::serialization::capnp::ReaderIndex::Pipeline( + _typeless.getPointerField(10)); } #endif // !CAPNP_LITE -inline void Query::Builder::setReaderIndex( ::tiledb::sm::serialization::capnp::ReaderIndex::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReaderIndex>::set(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS), value); +inline void Query::Builder::setReaderIndex( + ::tiledb::sm::serialization::capnp::ReaderIndex::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ReaderIndex>:: + set(_builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::ReaderIndex::Builder Query::Builder::initReaderIndex() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReaderIndex>::init(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ReaderIndex::Builder +Query::Builder::initReaderIndex() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ReaderIndex>::init( + _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptReaderIndex( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReaderIndex>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReaderIndex>::adopt(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReaderIndex>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ReaderIndex>:: + adopt( + _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ReaderIndex> Query::Builder::disownReaderIndex() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ReaderIndex>::disown(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ReaderIndex> +Query::Builder::disownReaderIndex() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ReaderIndex>::disown( + _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasDenseReader() const { - return !_reader.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS) + .isNull(); } inline bool Query::Builder::hasDenseReader() { - return !_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Reader Query::Reader::getDenseReader() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::get(_reader.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Reader +Query::Reader::getDenseReader() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::get( + _reader.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Builder Query::Builder::getDenseReader() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::get(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Builder +Query::Builder::getDenseReader() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::get( + _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline Query::Pipeline::getDenseReader() { - return ::tiledb::sm::serialization::capnp::QueryReader::Pipeline(_typeless.getPointerField(11)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline +Query::Pipeline::getDenseReader() { + return ::tiledb::sm::serialization::capnp::QueryReader::Pipeline( + _typeless.getPointerField(11)); } #endif // !CAPNP_LITE -inline void Query::Builder::setDenseReader( ::tiledb::sm::serialization::capnp::QueryReader::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::set(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS), value); +inline void Query::Builder::setDenseReader( + ::tiledb::sm::serialization::capnp::QueryReader::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>:: + set(_builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Builder Query::Builder::initDenseReader() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::init(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Builder +Query::Builder::initDenseReader() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::init( + _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptDenseReader( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::adopt(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>:: + adopt( + _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader> Query::Builder::disownDenseReader() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::disown(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader> +Query::Builder::disownDenseReader() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::disown( + _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasDelete() const { - return !_reader.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS) + .isNull(); } inline bool Query::Builder::hasDelete() { - return !_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Delete::Reader Query::Reader::getDelete() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Delete>::get(_reader.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Delete::Reader +Query::Reader::getDelete() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Delete>::get( + _reader.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Delete::Builder Query::Builder::getDelete() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Delete>::get(_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Delete::Builder +Query::Builder::getDelete() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Delete>::get( + _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Delete::Pipeline Query::Pipeline::getDelete() { - return ::tiledb::sm::serialization::capnp::Delete::Pipeline(_typeless.getPointerField(12)); +inline ::tiledb::sm::serialization::capnp::Delete::Pipeline +Query::Pipeline::getDelete() { + return ::tiledb::sm::serialization::capnp::Delete::Pipeline( + _typeless.getPointerField(12)); } #endif // !CAPNP_LITE -inline void Query::Builder::setDelete( ::tiledb::sm::serialization::capnp::Delete::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Delete>::set(_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS), value); +inline void Query::Builder::setDelete( + ::tiledb::sm::serialization::capnp::Delete::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Delete>::set( + _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Delete::Builder Query::Builder::initDelete() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Delete>::init(_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Delete::Builder +Query::Builder::initDelete() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Delete>::init( + _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptDelete( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Delete>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Delete>::adopt(_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Delete>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Delete>::adopt( + _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Delete> Query::Builder::disownDelete() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Delete>::disown(_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Delete> +Query::Builder::disownDelete() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Delete>::disown( + _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasWrittenFragmentInfo() const { - return !_reader.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS) + .isNull(); } inline bool Query::Builder::hasWrittenFragmentInfo() { - return !_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>::Reader Query::Reader::getWrittenFragmentInfo() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>::Builder Query::Builder::getWrittenFragmentInfo() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS)); -} -inline void Query::Builder::setWrittenFragmentInfo( ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>::Builder Query::Builder::initWrittenFragmentInfo(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>::Reader +Query::Reader::getWrittenFragmentInfo() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<13>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>::Builder +Query::Builder::getWrittenFragmentInfo() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<13>() * + ::capnp::POINTERS)); +} +inline void Query::Builder::setWrittenFragmentInfo( + ::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>::Builder +Query::Builder::initWrittenFragmentInfo(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), + size); } inline void Query::Builder::adoptWrittenFragmentInfo( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>> Query::Builder::disownWrittenFragmentInfo() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>> +Query::Builder::disownWrittenFragmentInfo() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::WrittenFragmentInfo, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<13>() * + ::capnp::POINTERS)); } inline bool Query::Reader::hasWrittenBuffers() const { - return !_reader.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS) + .isNull(); } inline bool Query::Builder::hasWrittenBuffers() { - return !_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader Query::Reader::getWrittenBuffers() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder Query::Builder::getWrittenBuffers() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS)); -} -inline void Query::Builder::setWrittenBuffers( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS), value); -} -inline void Query::Builder::setWrittenBuffers(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder Query::Builder::initWrittenBuffers(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +Query::Reader::getWrittenBuffers() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +Query::Builder::getWrittenBuffers() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS)); +} +inline void Query::Builder::setWrittenBuffers( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), + value); +} +inline void Query::Builder::setWrittenBuffers( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +Query::Builder::initWrittenBuffers(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), + size); } inline void Query::Builder::adoptWrittenBuffers( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> Query::Builder::disownWrittenBuffers() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +Query::Builder::disownWrittenBuffers() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasOrderedDimLabelReader() const { - return !_reader.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS) + .isNull(); } inline bool Query::Builder::hasOrderedDimLabelReader() { - return !_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Reader Query::Reader::getOrderedDimLabelReader() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::get(_reader.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Reader +Query::Reader::getOrderedDimLabelReader() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::get( + _reader.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Builder Query::Builder::getOrderedDimLabelReader() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::get(_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Builder +Query::Builder::getOrderedDimLabelReader() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::get( + _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline Query::Pipeline::getOrderedDimLabelReader() { - return ::tiledb::sm::serialization::capnp::QueryReader::Pipeline(_typeless.getPointerField(15)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Pipeline +Query::Pipeline::getOrderedDimLabelReader() { + return ::tiledb::sm::serialization::capnp::QueryReader::Pipeline( + _typeless.getPointerField(15)); } #endif // !CAPNP_LITE -inline void Query::Builder::setOrderedDimLabelReader( ::tiledb::sm::serialization::capnp::QueryReader::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::set(_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS), value); +inline void Query::Builder::setOrderedDimLabelReader( + ::tiledb::sm::serialization::capnp::QueryReader::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>:: + set(_builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::QueryReader::Builder Query::Builder::initOrderedDimLabelReader() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::init(_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::QueryReader::Builder +Query::Builder::initOrderedDimLabelReader() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::init( + _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS)); } inline void Query::Builder::adoptOrderedDimLabelReader( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::adopt(_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>:: + adopt( + _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::QueryReader> Query::Builder::disownOrderedDimLabelReader() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::QueryReader>::disown(_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::QueryReader> +Query::Builder::disownOrderedDimLabelReader() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::QueryReader>::disown( + _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS)); } inline bool Query::Reader::hasChannels() const { - return !_reader.getPointerField( - ::capnp::bounded<16>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS) + .isNull(); } inline bool Query::Builder::hasChannels() { - return !_builder.getPointerField( - ::capnp::bounded<16>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>::Reader Query::Reader::getChannels() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<16>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>::Builder Query::Builder::getChannels() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<16>() * ::capnp::POINTERS)); -} -inline void Query::Builder::setChannels( ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<16>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>::Builder Query::Builder::initChannels(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<16>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>::Reader +Query::Reader::getChannels() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<16>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>::Builder +Query::Builder::getChannels() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<16>() * + ::capnp::POINTERS)); +} +inline void Query::Builder::setChannels( + ::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>::Builder +Query::Builder::initChannels(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS), + size); } inline void Query::Builder::adoptChannels( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<16>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>> Query::Builder::disownChannels() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::QueryChannel, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<16>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>> +Query::Builder::disownChannels() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::QueryChannel, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<16>() * + ::capnp::POINTERS)); } inline bool NonEmptyDomain::Reader::hasNonEmptyDomain() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool NonEmptyDomain::Builder::hasNonEmptyDomain() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Reader NonEmptyDomain::Reader::getNonEmptyDomain() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Reader +NonEmptyDomain::Reader::getNonEmptyDomain() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Builder NonEmptyDomain::Builder::getNonEmptyDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Builder +NonEmptyDomain::Builder::getNonEmptyDomain() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline NonEmptyDomain::Pipeline::getNonEmptyDomain() { - return ::tiledb::sm::serialization::capnp::DomainArray::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Pipeline +NonEmptyDomain::Pipeline::getNonEmptyDomain() { + return ::tiledb::sm::serialization::capnp::DomainArray::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void NonEmptyDomain::Builder::setNonEmptyDomain( ::tiledb::sm::serialization::capnp::DomainArray::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void NonEmptyDomain::Builder::setNonEmptyDomain( + ::tiledb::sm::serialization::capnp::DomainArray::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::DomainArray::Builder NonEmptyDomain::Builder::initNonEmptyDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::DomainArray::Builder +NonEmptyDomain::Builder::initNonEmptyDomain() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void NonEmptyDomain::Builder::adoptNonEmptyDomain( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::DomainArray> NonEmptyDomain::Builder::disownNonEmptyDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::DomainArray>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::DomainArray> +NonEmptyDomain::Builder::disownNonEmptyDomain() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::DomainArray>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool NonEmptyDomain::Reader::getIsEmpty() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool NonEmptyDomain::Builder::getIsEmpty() { - return _builder.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void NonEmptyDomain::Builder::setIsEmpty(bool value) { - _builder.setDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool NonEmptyDomain::Reader::hasSizes() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool NonEmptyDomain::Builder::hasSizes() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader NonEmptyDomain::Reader::getSizes() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder NonEmptyDomain::Builder::getSizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void NonEmptyDomain::Builder::setSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline void NonEmptyDomain::Builder::setSizes(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder NonEmptyDomain::Builder::initSizes(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +NonEmptyDomain::Reader::getSizes() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +NonEmptyDomain::Builder::getSizes() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void NonEmptyDomain::Builder::setSizes( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline void NonEmptyDomain::Builder::setSizes( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +NonEmptyDomain::Builder::initSizes(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void NonEmptyDomain::Builder::adoptSizes( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> NonEmptyDomain::Builder::disownSizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +NonEmptyDomain::Builder::disownSizes() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool NonEmptyDomainList::Reader::hasNonEmptyDomains() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool NonEmptyDomainList::Builder::hasNonEmptyDomains() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>::Reader NonEmptyDomainList::Reader::getNonEmptyDomains() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>::Builder NonEmptyDomainList::Builder::getNonEmptyDomains() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void NonEmptyDomainList::Builder::setNonEmptyDomains( ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>::Builder NonEmptyDomainList::Builder::initNonEmptyDomains(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>::Reader +NonEmptyDomainList::Reader::getNonEmptyDomains() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>::Builder +NonEmptyDomainList::Builder::getNonEmptyDomains() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void NonEmptyDomainList::Builder::setNonEmptyDomains( + ::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>::Builder +NonEmptyDomainList::Builder::initNonEmptyDomains(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void NonEmptyDomainList::Builder::adoptNonEmptyDomains( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>> NonEmptyDomainList::Builder::disownNonEmptyDomains() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::NonEmptyDomain, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>> +NonEmptyDomainList::Builder::disownNonEmptyDomains() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::NonEmptyDomain, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } inline bool AttributeBufferSize::Reader::hasAttribute() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool AttributeBufferSize::Builder::hasAttribute() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader AttributeBufferSize::Reader::getAttribute() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader AttributeBufferSize::Reader::getAttribute() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder AttributeBufferSize::Builder::getAttribute() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder AttributeBufferSize::Builder::getAttribute() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void AttributeBufferSize::Builder::setAttribute( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void AttributeBufferSize::Builder::setAttribute( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder AttributeBufferSize::Builder::initAttribute(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder AttributeBufferSize::Builder::initAttribute( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void AttributeBufferSize::Builder::adoptAttribute( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> AttributeBufferSize::Builder::disownAttribute() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +AttributeBufferSize::Builder::disownAttribute() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t AttributeBufferSize::Reader::getOffsetBytes() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t AttributeBufferSize::Reader::getOffsetBytes() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t AttributeBufferSize::Builder::getOffsetBytes() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t AttributeBufferSize::Builder::getOffsetBytes() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void AttributeBufferSize::Builder::setOffsetBytes( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void AttributeBufferSize::Builder::setOffsetBytes(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t AttributeBufferSize::Reader::getDataBytes() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t AttributeBufferSize::Reader::getDataBytes() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t AttributeBufferSize::Builder::getDataBytes() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t AttributeBufferSize::Builder::getDataBytes() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void AttributeBufferSize::Builder::setDataBytes( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void AttributeBufferSize::Builder::setDataBytes(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t AttributeBufferSize::Reader::getValidityBytes() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t AttributeBufferSize::Reader::getValidityBytes() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t AttributeBufferSize::Builder::getValidityBytes() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t AttributeBufferSize::Builder::getValidityBytes() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void AttributeBufferSize::Builder::setValidityBytes( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void AttributeBufferSize::Builder::setValidityBytes(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool ArrayMetadata::Reader::hasEntries() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayMetadata::Builder::hasEntries() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>::Reader ArrayMetadata::Reader::getEntries() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>::Builder ArrayMetadata::Builder::getEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void ArrayMetadata::Builder::setEntries( ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>::Builder ArrayMetadata::Builder::initEntries(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>::Reader +ArrayMetadata::Reader::getEntries() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>::Builder +ArrayMetadata::Builder::getEntries() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void ArrayMetadata::Builder::setEntries( + ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>::Builder +ArrayMetadata::Builder::initEntries(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void ArrayMetadata::Builder::adoptEntries( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>> ArrayMetadata::Builder::disownEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>> +ArrayMetadata::Builder::disownEntries() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayMetadata::MetadataEntry, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } inline bool ArrayMetadata::MetadataEntry::Reader::hasKey() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayMetadata::MetadataEntry::Builder::hasKey() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::Text::Reader ArrayMetadata::MetadataEntry::Reader::getKey() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder ArrayMetadata::MetadataEntry::Builder::getKey() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void ArrayMetadata::MetadataEntry::Builder::setKey( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::Text::Builder ArrayMetadata::MetadataEntry::Builder::initKey(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::Text::Reader ArrayMetadata::MetadataEntry::Reader::getKey() + const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder ArrayMetadata::MetadataEntry::Builder::getKey() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void ArrayMetadata::MetadataEntry::Builder::setKey( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::Text::Builder ArrayMetadata::MetadataEntry::Builder::initKey( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void ArrayMetadata::MetadataEntry::Builder::adoptKey( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> ArrayMetadata::MetadataEntry::Builder::disownKey() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +ArrayMetadata::MetadataEntry::Builder::disownKey() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ArrayMetadata::MetadataEntry::Reader::hasType() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayMetadata::MetadataEntry::Builder::hasType() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::Text::Reader ArrayMetadata::MetadataEntry::Reader::getType() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder ArrayMetadata::MetadataEntry::Builder::getType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void ArrayMetadata::MetadataEntry::Builder::setType( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::Text::Builder ArrayMetadata::MetadataEntry::Builder::initType(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::Text::Reader ArrayMetadata::MetadataEntry::Reader::getType() + const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder ArrayMetadata::MetadataEntry::Builder::getType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void ArrayMetadata::MetadataEntry::Builder::setType( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::Text::Builder ArrayMetadata::MetadataEntry::Builder::initType( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void ArrayMetadata::MetadataEntry::Builder::adoptType( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> ArrayMetadata::MetadataEntry::Builder::disownType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +ArrayMetadata::MetadataEntry::Builder::disownType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::uint32_t ArrayMetadata::MetadataEntry::Reader::getValueNum() const { - return _reader.getDataField< ::uint32_t>( +inline ::uint32_t ArrayMetadata::MetadataEntry::Reader::getValueNum() const { + return _reader.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint32_t ArrayMetadata::MetadataEntry::Builder::getValueNum() { - return _builder.getDataField< ::uint32_t>( +inline ::uint32_t ArrayMetadata::MetadataEntry::Builder::getValueNum() { + return _builder.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ArrayMetadata::MetadataEntry::Builder::setValueNum( ::uint32_t value) { - _builder.setDataField< ::uint32_t>( +inline void ArrayMetadata::MetadataEntry::Builder::setValueNum( + ::uint32_t value) { + _builder.setDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool ArrayMetadata::MetadataEntry::Reader::hasValue() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayMetadata::MetadataEntry::Builder::hasValue() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::Data::Reader ArrayMetadata::MetadataEntry::Reader::getValue() const { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::Data::Builder ArrayMetadata::MetadataEntry::Builder::getValue() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void ArrayMetadata::MetadataEntry::Builder::setValue( ::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline ::capnp::Data::Builder ArrayMetadata::MetadataEntry::Builder::initValue(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::Data::Reader ArrayMetadata::MetadataEntry::Reader::getValue() + const { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::Data::Builder +ArrayMetadata::MetadataEntry::Builder::getValue() { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void ArrayMetadata::MetadataEntry::Builder::setValue( + ::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Data>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline ::capnp::Data::Builder ArrayMetadata::MetadataEntry::Builder::initValue( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Data>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void ArrayMetadata::MetadataEntry::Builder::adoptValue( - ::capnp::Orphan< ::capnp::Data>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Data>&& value) { + ::capnp::_::PointerHelpers<::capnp::Data>::adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Data> ArrayMetadata::MetadataEntry::Builder::disownValue() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Data> +ArrayMetadata::MetadataEntry::Builder::disownValue() { + return ::capnp::_::PointerHelpers<::capnp::Data>::disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool ArrayMetadata::MetadataEntry::Reader::getDel() const { - return _reader.getDataField( - ::capnp::bounded<32>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<32>() * ::capnp::ELEMENTS); } inline bool ArrayMetadata::MetadataEntry::Builder::getDel() { @@ -20750,697 +27565,1087 @@ inline void ArrayMetadata::MetadataEntry::Builder::setDel(bool value) { } inline bool ArrayDirectory::Reader::hasUnfilteredFragmentUris() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayDirectory::Builder::hasUnfilteredFragmentUris() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getUnfilteredFragmentUris() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getUnfilteredFragmentUris() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setUnfilteredFragmentUris( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline void ArrayDirectory::Builder::setUnfilteredFragmentUris(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initUnfilteredFragmentUris(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +ArrayDirectory::Reader::getUnfilteredFragmentUris() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::getUnfilteredFragmentUris() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setUnfilteredFragmentUris( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline void ArrayDirectory::Builder::setUnfilteredFragmentUris( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::initUnfilteredFragmentUris(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void ArrayDirectory::Builder::adoptUnfilteredFragmentUris( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownUnfilteredFragmentUris() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +ArrayDirectory::Builder::disownUnfilteredFragmentUris() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasConsolidatedCommitUris() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayDirectory::Builder::hasConsolidatedCommitUris() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getConsolidatedCommitUris() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getConsolidatedCommitUris() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setConsolidatedCommitUris( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline void ArrayDirectory::Builder::setConsolidatedCommitUris(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initConsolidatedCommitUris(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +ArrayDirectory::Reader::getConsolidatedCommitUris() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::getConsolidatedCommitUris() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setConsolidatedCommitUris( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline void ArrayDirectory::Builder::setConsolidatedCommitUris( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::initConsolidatedCommitUris(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void ArrayDirectory::Builder::adoptConsolidatedCommitUris( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownConsolidatedCommitUris() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +ArrayDirectory::Builder::disownConsolidatedCommitUris() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasArraySchemaUris() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayDirectory::Builder::hasArraySchemaUris() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getArraySchemaUris() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getArraySchemaUris() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setArraySchemaUris( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline void ArrayDirectory::Builder::setArraySchemaUris(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initArraySchemaUris(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +ArrayDirectory::Reader::getArraySchemaUris() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::getArraySchemaUris() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setArraySchemaUris( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline void ArrayDirectory::Builder::setArraySchemaUris( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::initArraySchemaUris(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void ArrayDirectory::Builder::adoptArraySchemaUris( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownArraySchemaUris() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +ArrayDirectory::Builder::disownArraySchemaUris() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasLatestArraySchemaUri() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayDirectory::Builder::hasLatestArraySchemaUri() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::Text::Reader ArrayDirectory::Reader::getLatestArraySchemaUri() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder ArrayDirectory::Builder::getLatestArraySchemaUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setLatestArraySchemaUri( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline ::capnp::Text::Builder ArrayDirectory::Builder::initLatestArraySchemaUri(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::Text::Reader ArrayDirectory::Reader::getLatestArraySchemaUri() + const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder +ArrayDirectory::Builder::getLatestArraySchemaUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setLatestArraySchemaUri( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline ::capnp::Text::Builder ArrayDirectory::Builder::initLatestArraySchemaUri( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + size); } inline void ArrayDirectory::Builder::adoptLatestArraySchemaUri( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> ArrayDirectory::Builder::disownLatestArraySchemaUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +ArrayDirectory::Builder::disownLatestArraySchemaUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasArrayMetaUrisToVacuum() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayDirectory::Builder::hasArrayMetaUrisToVacuum() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getArrayMetaUrisToVacuum() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getArrayMetaUrisToVacuum() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setArrayMetaUrisToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); -} -inline void ArrayDirectory::Builder::setArrayMetaUrisToVacuum(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initArrayMetaUrisToVacuum(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +ArrayDirectory::Reader::getArrayMetaUrisToVacuum() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::getArrayMetaUrisToVacuum() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setArrayMetaUrisToVacuum( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); +} +inline void ArrayDirectory::Builder::setArrayMetaUrisToVacuum( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::initArrayMetaUrisToVacuum(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + size); } inline void ArrayDirectory::Builder::adoptArrayMetaUrisToVacuum( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownArrayMetaUrisToVacuum() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +ArrayDirectory::Builder::disownArrayMetaUrisToVacuum() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasArrayMetaVacUrisToVacuum() const { - return !_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayDirectory::Builder::hasArrayMetaVacUrisToVacuum() { - return !_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getArrayMetaVacUrisToVacuum() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getArrayMetaVacUrisToVacuum() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setArrayMetaVacUrisToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), value); -} -inline void ArrayDirectory::Builder::setArrayMetaVacUrisToVacuum(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initArrayMetaVacUrisToVacuum(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +ArrayDirectory::Reader::getArrayMetaVacUrisToVacuum() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::getArrayMetaVacUrisToVacuum() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setArrayMetaVacUrisToVacuum( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + value); +} +inline void ArrayDirectory::Builder::setArrayMetaVacUrisToVacuum( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::initArrayMetaVacUrisToVacuum(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + size); } inline void ArrayDirectory::Builder::adoptArrayMetaVacUrisToVacuum( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownArrayMetaVacUrisToVacuum() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +ArrayDirectory::Builder::disownArrayMetaVacUrisToVacuum() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasCommitUrisToConsolidate() const { - return !_reader.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayDirectory::Builder::hasCommitUrisToConsolidate() { - return !_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getCommitUrisToConsolidate() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getCommitUrisToConsolidate() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setCommitUrisToConsolidate( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), value); -} -inline void ArrayDirectory::Builder::setCommitUrisToConsolidate(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initCommitUrisToConsolidate(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +ArrayDirectory::Reader::getCommitUrisToConsolidate() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::getCommitUrisToConsolidate() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setCommitUrisToConsolidate( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + value); +} +inline void ArrayDirectory::Builder::setCommitUrisToConsolidate( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::initCommitUrisToConsolidate(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + size); } inline void ArrayDirectory::Builder::adoptCommitUrisToConsolidate( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownCommitUrisToConsolidate() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +ArrayDirectory::Builder::disownCommitUrisToConsolidate() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasCommitUrisToVacuum() const { - return !_reader.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayDirectory::Builder::hasCommitUrisToVacuum() { - return !_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getCommitUrisToVacuum() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getCommitUrisToVacuum() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setCommitUrisToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), value); -} -inline void ArrayDirectory::Builder::setCommitUrisToVacuum(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initCommitUrisToVacuum(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +ArrayDirectory::Reader::getCommitUrisToVacuum() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::getCommitUrisToVacuum() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setCommitUrisToVacuum( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + value); +} +inline void ArrayDirectory::Builder::setCommitUrisToVacuum( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::initCommitUrisToVacuum(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + size); } inline void ArrayDirectory::Builder::adoptCommitUrisToVacuum( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownCommitUrisToVacuum() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +ArrayDirectory::Builder::disownCommitUrisToVacuum() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasConsolidatedCommitUrisToVacuum() const { - return !_reader.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayDirectory::Builder::hasConsolidatedCommitUrisToVacuum() { - return !_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getConsolidatedCommitUrisToVacuum() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getConsolidatedCommitUrisToVacuum() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setConsolidatedCommitUrisToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), value); -} -inline void ArrayDirectory::Builder::setConsolidatedCommitUrisToVacuum(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initConsolidatedCommitUrisToVacuum(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +ArrayDirectory::Reader::getConsolidatedCommitUrisToVacuum() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::getConsolidatedCommitUrisToVacuum() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setConsolidatedCommitUrisToVacuum( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + value); +} +inline void ArrayDirectory::Builder::setConsolidatedCommitUrisToVacuum( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::initConsolidatedCommitUrisToVacuum(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + size); } inline void ArrayDirectory::Builder::adoptConsolidatedCommitUrisToVacuum( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownConsolidatedCommitUrisToVacuum() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +ArrayDirectory::Builder::disownConsolidatedCommitUrisToVacuum() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasArrayMetaUris() const { - return !_reader.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayDirectory::Builder::hasArrayMetaUris() { - return !_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>::Reader ArrayDirectory::Reader::getArrayMetaUris() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>::Builder ArrayDirectory::Builder::getArrayMetaUris() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setArrayMetaUris( ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>::Builder ArrayDirectory::Builder::initArrayMetaUris(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>::Reader +ArrayDirectory::Reader::getArrayMetaUris() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<9>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>::Builder +ArrayDirectory::Builder::getArrayMetaUris() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<9>() * + ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setArrayMetaUris( + ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>::Builder +ArrayDirectory::Builder::initArrayMetaUris(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), + size); } inline void ArrayDirectory::Builder::adoptArrayMetaUris( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>> ArrayDirectory::Builder::disownArrayMetaUris() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>> +ArrayDirectory::Builder::disownArrayMetaUris() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory::TimestampedURI, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<9>() * + ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasFragmentMetaUris() const { - return !_reader.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayDirectory::Builder::hasFragmentMetaUris() { - return !_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDirectory::Reader::getFragmentMetaUris() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::getFragmentMetaUris() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setFragmentMetaUris( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS), value); -} -inline void ArrayDirectory::Builder::setFragmentMetaUris(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDirectory::Builder::initFragmentMetaUris(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +ArrayDirectory::Reader::getFragmentMetaUris() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::getFragmentMetaUris() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setFragmentMetaUris( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), + value); +} +inline void ArrayDirectory::Builder::setFragmentMetaUris( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDirectory::Builder::initFragmentMetaUris(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), + size); } inline void ArrayDirectory::Builder::adoptFragmentMetaUris( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDirectory::Builder::disownFragmentMetaUris() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +ArrayDirectory::Builder::disownFragmentMetaUris() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS)); } inline bool ArrayDirectory::Reader::hasDeleteAndUpdateTileLocation() const { - return !_reader.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayDirectory::Builder::hasDeleteAndUpdateTileLocation() { - return !_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>::Reader ArrayDirectory::Reader::getDeleteAndUpdateTileLocation() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>::Builder ArrayDirectory::Builder::getDeleteAndUpdateTileLocation() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::Builder::setDeleteAndUpdateTileLocation( ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>::Builder ArrayDirectory::Builder::initDeleteAndUpdateTileLocation(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>::Reader +ArrayDirectory::Reader::getDeleteAndUpdateTileLocation() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<11>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>::Builder +ArrayDirectory::Builder::getDeleteAndUpdateTileLocation() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<11>() * + ::capnp::POINTERS)); +} +inline void ArrayDirectory::Builder::setDeleteAndUpdateTileLocation( + ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>::Builder +ArrayDirectory::Builder::initDeleteAndUpdateTileLocation(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), + size); } inline void ArrayDirectory::Builder::adoptDeleteAndUpdateTileLocation( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>> ArrayDirectory::Builder::disownDeleteAndUpdateTileLocation() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::ArrayDirectory::DeleteAndUpdateTileLocation, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS)); -} - -inline ::uint64_t ArrayDirectory::Reader::getTimestampStart() const { - return _reader.getDataField< ::uint64_t>( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>> +ArrayDirectory::Builder::disownDeleteAndUpdateTileLocation() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ArrayDirectory:: + DeleteAndUpdateTileLocation, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<11>() * + ::capnp::POINTERS)); +} + +inline ::uint64_t ArrayDirectory::Reader::getTimestampStart() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t ArrayDirectory::Builder::getTimestampStart() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t ArrayDirectory::Builder::getTimestampStart() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ArrayDirectory::Builder::setTimestampStart( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void ArrayDirectory::Builder::setTimestampStart(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t ArrayDirectory::Reader::getTimestampEnd() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t ArrayDirectory::Reader::getTimestampEnd() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t ArrayDirectory::Builder::getTimestampEnd() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t ArrayDirectory::Builder::getTimestampEnd() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void ArrayDirectory::Builder::setTimestampEnd( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void ArrayDirectory::Builder::setTimestampEnd(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool ArrayDirectory::TimestampedURI::Reader::hasUri() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayDirectory::TimestampedURI::Builder::hasUri() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::Text::Reader ArrayDirectory::TimestampedURI::Reader::getUri() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder ArrayDirectory::TimestampedURI::Builder::getUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::TimestampedURI::Builder::setUri( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::Text::Builder ArrayDirectory::TimestampedURI::Builder::initUri(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::Text::Reader ArrayDirectory::TimestampedURI::Reader::getUri() + const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder +ArrayDirectory::TimestampedURI::Builder::getUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::TimestampedURI::Builder::setUri( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::Text::Builder ArrayDirectory::TimestampedURI::Builder::initUri( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void ArrayDirectory::TimestampedURI::Builder::adoptUri( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> ArrayDirectory::TimestampedURI::Builder::disownUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +ArrayDirectory::TimestampedURI::Builder::disownUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t ArrayDirectory::TimestampedURI::Reader::getTimestampStart() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t ArrayDirectory::TimestampedURI::Reader::getTimestampStart() + const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t ArrayDirectory::TimestampedURI::Builder::getTimestampStart() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t ArrayDirectory::TimestampedURI::Builder::getTimestampStart() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ArrayDirectory::TimestampedURI::Builder::setTimestampStart( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void ArrayDirectory::TimestampedURI::Builder::setTimestampStart( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t ArrayDirectory::TimestampedURI::Reader::getTimestampEnd() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t ArrayDirectory::TimestampedURI::Reader::getTimestampEnd() + const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t ArrayDirectory::TimestampedURI::Builder::getTimestampEnd() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t ArrayDirectory::TimestampedURI::Builder::getTimestampEnd() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void ArrayDirectory::TimestampedURI::Builder::setTimestampEnd( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void ArrayDirectory::TimestampedURI::Builder::setTimestampEnd( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline bool ArrayDirectory::DeleteAndUpdateTileLocation::Reader::hasUri() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +inline bool ArrayDirectory::DeleteAndUpdateTileLocation::Reader::hasUri() + const { + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayDirectory::DeleteAndUpdateTileLocation::Builder::hasUri() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::Text::Reader ArrayDirectory::DeleteAndUpdateTileLocation::Reader::getUri() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder ArrayDirectory::DeleteAndUpdateTileLocation::Builder::getUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::DeleteAndUpdateTileLocation::Builder::setUri( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::Text::Builder ArrayDirectory::DeleteAndUpdateTileLocation::Builder::initUri(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::Text::Reader +ArrayDirectory::DeleteAndUpdateTileLocation::Reader::getUri() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder +ArrayDirectory::DeleteAndUpdateTileLocation::Builder::getUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void ArrayDirectory::DeleteAndUpdateTileLocation::Builder::setUri( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::Text::Builder +ArrayDirectory::DeleteAndUpdateTileLocation::Builder::initUri( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void ArrayDirectory::DeleteAndUpdateTileLocation::Builder::adoptUri( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::Text> ArrayDirectory::DeleteAndUpdateTileLocation::Builder::disownUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} - -inline bool ArrayDirectory::DeleteAndUpdateTileLocation::Reader::hasConditionMarker() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline bool ArrayDirectory::DeleteAndUpdateTileLocation::Builder::hasConditionMarker() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::Text::Reader ArrayDirectory::DeleteAndUpdateTileLocation::Reader::getConditionMarker() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder ArrayDirectory::DeleteAndUpdateTileLocation::Builder::getConditionMarker() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void ArrayDirectory::DeleteAndUpdateTileLocation::Builder::setConditionMarker( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::Text::Builder ArrayDirectory::DeleteAndUpdateTileLocation::Builder::initConditionMarker(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); -} -inline void ArrayDirectory::DeleteAndUpdateTileLocation::Builder::adoptConditionMarker( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::Text> ArrayDirectory::DeleteAndUpdateTileLocation::Builder::disownConditionMarker() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} - -inline ::uint64_t ArrayDirectory::DeleteAndUpdateTileLocation::Reader::getOffset() const { - return _reader.getDataField< ::uint64_t>( + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::Text> +ArrayDirectory::DeleteAndUpdateTileLocation::Builder::disownUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool +ArrayDirectory::DeleteAndUpdateTileLocation::Reader::hasConditionMarker() + const { + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline bool +ArrayDirectory::DeleteAndUpdateTileLocation::Builder::hasConditionMarker() { + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::Text::Reader +ArrayDirectory::DeleteAndUpdateTileLocation::Reader::getConditionMarker() + const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder +ArrayDirectory::DeleteAndUpdateTileLocation::Builder::getConditionMarker() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void +ArrayDirectory::DeleteAndUpdateTileLocation::Builder::setConditionMarker( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::Text::Builder +ArrayDirectory::DeleteAndUpdateTileLocation::Builder::initConditionMarker( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); +} +inline void +ArrayDirectory::DeleteAndUpdateTileLocation::Builder::adoptConditionMarker( + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::Text> +ArrayDirectory::DeleteAndUpdateTileLocation::Builder::disownConditionMarker() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline ::uint64_t +ArrayDirectory::DeleteAndUpdateTileLocation::Reader::getOffset() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t ArrayDirectory::DeleteAndUpdateTileLocation::Builder::getOffset() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t +ArrayDirectory::DeleteAndUpdateTileLocation::Builder::getOffset() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ArrayDirectory::DeleteAndUpdateTileLocation::Builder::setOffset( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void ArrayDirectory::DeleteAndUpdateTileLocation::Builder::setOffset( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool EstimatedResultSize::Reader::hasResultSizes() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool EstimatedResultSize::Builder::hasResultSizes() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Reader EstimatedResultSize::Reader::getResultSizes() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Builder EstimatedResultSize::Builder::getResultSizes() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Pipeline EstimatedResultSize::Pipeline::getResultSizes() { - return ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Pipeline(_typeless.getPointerField(0)); -} -#endif // !CAPNP_LITE -inline void EstimatedResultSize::Builder::setResultSizes( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Builder EstimatedResultSize::Builder::initResultSizes() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>::Reader +EstimatedResultSize::Reader::getResultSizes() const { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>:: + get(_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: + Builder + EstimatedResultSize::Builder::getResultSizes() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>:: + get(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: + Pipeline + EstimatedResultSize::Pipeline::getResultSizes() { + return ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: + Pipeline(_typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +inline void EstimatedResultSize::Builder::setResultSizes( + ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: + Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>:: + Builder + EstimatedResultSize::Builder::initResultSizes() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>:: + init(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void EstimatedResultSize::Builder::adoptResultSizes( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>> EstimatedResultSize::Builder::disownResultSizes() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>&& + value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>> +EstimatedResultSize::Builder::disownResultSizes() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::ResultSize>>:: + disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool EstimatedResultSize::Reader::hasMemorySizes() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool EstimatedResultSize::Builder::hasMemorySizes() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Reader EstimatedResultSize::Reader::getMemorySizes() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Builder EstimatedResultSize::Builder::getMemorySizes() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Pipeline EstimatedResultSize::Pipeline::getMemorySizes() { - return ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Pipeline(_typeless.getPointerField(1)); -} -#endif // !CAPNP_LITE -inline void EstimatedResultSize::Builder::setMemorySizes( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Builder EstimatedResultSize::Builder::initMemorySizes() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>::Reader +EstimatedResultSize::Reader::getMemorySizes() const { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>:: + get(_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: + Builder + EstimatedResultSize::Builder::getMemorySizes() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>:: + get(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: + Pipeline + EstimatedResultSize::Pipeline::getMemorySizes() { + return ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: + Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void EstimatedResultSize::Builder::setMemorySizes( + ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: + Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>:: + set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>:: + Builder + EstimatedResultSize::Builder::initMemorySizes() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>:: + init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void EstimatedResultSize::Builder::adoptMemorySizes( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>> EstimatedResultSize::Builder::disownMemorySizes() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>&& + value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>> +EstimatedResultSize::Builder::disownMemorySizes() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::EstimatedResultSize::MemorySize>>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline double EstimatedResultSize::ResultSize::Reader::getSizeFixed() const { @@ -21452,7 +28657,8 @@ inline double EstimatedResultSize::ResultSize::Builder::getSizeFixed() { return _builder.getDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void EstimatedResultSize::ResultSize::Builder::setSizeFixed(double value) { +inline void EstimatedResultSize::ResultSize::Builder::setSizeFixed( + double value) { _builder.setDataField( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } @@ -21480,3939 +28686,6010 @@ inline double EstimatedResultSize::ResultSize::Builder::getSizeValidity() { return _builder.getDataField( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void EstimatedResultSize::ResultSize::Builder::setSizeValidity(double value) { +inline void EstimatedResultSize::ResultSize::Builder::setSizeValidity( + double value) { _builder.setDataField( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t EstimatedResultSize::MemorySize::Reader::getSizeFixed() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t EstimatedResultSize::MemorySize::Reader::getSizeFixed() + const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t EstimatedResultSize::MemorySize::Builder::getSizeFixed() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t EstimatedResultSize::MemorySize::Builder::getSizeFixed() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void EstimatedResultSize::MemorySize::Builder::setSizeFixed( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void EstimatedResultSize::MemorySize::Builder::setSizeFixed( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t EstimatedResultSize::MemorySize::Reader::getSizeVar() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t EstimatedResultSize::MemorySize::Reader::getSizeVar() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t EstimatedResultSize::MemorySize::Builder::getSizeVar() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t EstimatedResultSize::MemorySize::Builder::getSizeVar() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void EstimatedResultSize::MemorySize::Builder::setSizeVar( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void EstimatedResultSize::MemorySize::Builder::setSizeVar( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t EstimatedResultSize::MemorySize::Reader::getSizeValidity() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t EstimatedResultSize::MemorySize::Reader::getSizeValidity() + const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t EstimatedResultSize::MemorySize::Builder::getSizeValidity() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t EstimatedResultSize::MemorySize::Builder::getSizeValidity() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void EstimatedResultSize::MemorySize::Builder::setSizeValidity( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void EstimatedResultSize::MemorySize::Builder::setSizeValidity( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool FragmentInfoRequest::Reader::hasConfig() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentInfoRequest::Builder::hasConfig() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader FragmentInfoRequest::Reader::getConfig() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader +FragmentInfoRequest::Reader::getConfig() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder FragmentInfoRequest::Builder::getConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +FragmentInfoRequest::Builder::getConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline FragmentInfoRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline +FragmentInfoRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void FragmentInfoRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void FragmentInfoRequest::Builder::setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder FragmentInfoRequest::Builder::initConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +FragmentInfoRequest::Builder::initConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void FragmentInfoRequest::Builder::adoptConfig( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> FragmentInfoRequest::Builder::disownConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> +FragmentInfoRequest::Builder::disownConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool SingleFragmentInfo::Reader::hasArraySchemaName() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool SingleFragmentInfo::Builder::hasArraySchemaName() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::Text::Reader SingleFragmentInfo::Reader::getArraySchemaName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder SingleFragmentInfo::Builder::getArraySchemaName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void SingleFragmentInfo::Builder::setArraySchemaName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::Text::Builder SingleFragmentInfo::Builder::initArraySchemaName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::Text::Reader SingleFragmentInfo::Reader::getArraySchemaName() + const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder +SingleFragmentInfo::Builder::getArraySchemaName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void SingleFragmentInfo::Builder::setArraySchemaName( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::Text::Builder SingleFragmentInfo::Builder::initArraySchemaName( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void SingleFragmentInfo::Builder::adoptArraySchemaName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> SingleFragmentInfo::Builder::disownArraySchemaName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +SingleFragmentInfo::Builder::disownArraySchemaName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool SingleFragmentInfo::Reader::hasMeta() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool SingleFragmentInfo::Builder::hasMeta() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader SingleFragmentInfo::Reader::getMeta() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader +SingleFragmentInfo::Reader::getMeta() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder SingleFragmentInfo::Builder::getMeta() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder +SingleFragmentInfo::Builder::getMeta() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline SingleFragmentInfo::Pipeline::getMeta() { - return ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline(_typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline +SingleFragmentInfo::Pipeline::getMeta() { + return ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline( + _typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void SingleFragmentInfo::Builder::setMeta( ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void SingleFragmentInfo::Builder::setMeta( + ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder SingleFragmentInfo::Builder::initMeta() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder +SingleFragmentInfo::Builder::initMeta() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::FragmentMetadata>:: + init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void SingleFragmentInfo::Builder::adoptMeta( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata> SingleFragmentInfo::Builder::disownMeta() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} - -inline ::uint64_t SingleFragmentInfo::Reader::getFragmentSize() const { - return _reader.getDataField< ::uint64_t>( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata>&& + value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::FragmentMetadata>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata> +SingleFragmentInfo::Builder::disownMeta() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::FragmentMetadata>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline ::uint64_t SingleFragmentInfo::Reader::getFragmentSize() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t SingleFragmentInfo::Builder::getFragmentSize() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t SingleFragmentInfo::Builder::getFragmentSize() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void SingleFragmentInfo::Builder::setFragmentSize( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void SingleFragmentInfo::Builder::setFragmentSize(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool FragmentInfo::Reader::hasArraySchemaLatest() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentInfo::Builder::hasArraySchemaLatest() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader FragmentInfo::Reader::getArraySchemaLatest() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader +FragmentInfo::Reader::getArraySchemaLatest() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder FragmentInfo::Builder::getArraySchemaLatest() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder +FragmentInfo::Builder::getArraySchemaLatest() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline FragmentInfo::Pipeline::getArraySchemaLatest() { - return ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline +FragmentInfo::Pipeline::getArraySchemaLatest() { + return ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void FragmentInfo::Builder::setArraySchemaLatest( ::tiledb::sm::serialization::capnp::ArraySchema::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void FragmentInfo::Builder::setArraySchemaLatest( + ::tiledb::sm::serialization::capnp::ArraySchema::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder FragmentInfo::Builder::initArraySchemaLatest() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder +FragmentInfo::Builder::initArraySchemaLatest() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void FragmentInfo::Builder::adoptArraySchemaLatest( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema> FragmentInfo::Builder::disownArraySchemaLatest() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema> +FragmentInfo::Builder::disownArraySchemaLatest() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool FragmentInfo::Reader::hasArraySchemasAll() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentInfo::Builder::hasArraySchemasAll() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader FragmentInfo::Reader::getArraySchemasAll() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder FragmentInfo::Builder::getArraySchemasAll() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline FragmentInfo::Pipeline::getArraySchemasAll() { - return ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline(_typeless.getPointerField(1)); -} -#endif // !CAPNP_LITE -inline void FragmentInfo::Builder::setArraySchemasAll( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder FragmentInfo::Builder::initArraySchemasAll() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::tiledb::sm::serialization::capnp:: + Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader + FragmentInfo::Reader::getArraySchemasAll() const { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + get(_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp:: + Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder + FragmentInfo::Builder::getArraySchemasAll() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + get(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline +FragmentInfo::Pipeline::getArraySchemasAll() { + return ::tiledb::sm::serialization::capnp:: + Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>:: + Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void FragmentInfo::Builder::setArraySchemasAll( + ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::tiledb::sm::serialization::capnp:: + Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder + FragmentInfo::Builder::initArraySchemasAll() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void FragmentInfo::Builder::adoptArraySchemasAll( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>> FragmentInfo::Builder::disownArraySchemasAll() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>> +FragmentInfo::Builder::disownArraySchemasAll() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool FragmentInfo::Reader::hasFragmentInfo() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentInfo::Builder::hasFragmentInfo() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>::Reader FragmentInfo::Reader::getFragmentInfo() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>::Builder FragmentInfo::Builder::getFragmentInfo() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void FragmentInfo::Builder::setFragmentInfo( ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>::Builder FragmentInfo::Builder::initFragmentInfo(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>::Reader +FragmentInfo::Reader::getFragmentInfo() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<2>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>::Builder +FragmentInfo::Builder::getFragmentInfo() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<2>() * + ::capnp::POINTERS)); +} +inline void FragmentInfo::Builder::setFragmentInfo( + ::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>::Builder +FragmentInfo::Builder::initFragmentInfo(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void FragmentInfo::Builder::adoptFragmentInfo( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>> FragmentInfo::Builder::disownFragmentInfo() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SingleFragmentInfo, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>> +FragmentInfo::Builder::disownFragmentInfo() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SingleFragmentInfo, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<2>() * + ::capnp::POINTERS)); } inline bool FragmentInfo::Reader::hasToVacuum() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentInfo::Builder::hasToVacuum() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader FragmentInfo::Reader::getToVacuum() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder FragmentInfo::Builder::getToVacuum() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline void FragmentInfo::Builder::setToVacuum( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline void FragmentInfo::Builder::setToVacuum(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder FragmentInfo::Builder::initToVacuum(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +FragmentInfo::Reader::getToVacuum() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +FragmentInfo::Builder::getToVacuum() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void FragmentInfo::Builder::setToVacuum( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline void FragmentInfo::Builder::setToVacuum( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +FragmentInfo::Builder::initToVacuum(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + size); } inline void FragmentInfo::Builder::adoptToVacuum( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> FragmentInfo::Builder::disownToVacuum() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +FragmentInfo::Builder::disownToVacuum() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool GroupMetadata::Reader::hasConfig() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool GroupMetadata::Builder::hasConfig() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader GroupMetadata::Reader::getConfig() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader +GroupMetadata::Reader::getConfig() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder GroupMetadata::Builder::getConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +GroupMetadata::Builder::getConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline GroupMetadata::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline +GroupMetadata::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void GroupMetadata::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void GroupMetadata::Builder::setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder GroupMetadata::Builder::initConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +GroupMetadata::Builder::initConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void GroupMetadata::Builder::adoptConfig( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> GroupMetadata::Builder::disownConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> +GroupMetadata::Builder::disownConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool GroupMetadata::Reader::hasMetadata() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool GroupMetadata::Builder::hasMetadata() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader GroupMetadata::Reader::getMetadata() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader +GroupMetadata::Reader::getMetadata() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder GroupMetadata::Builder::getMetadata() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder +GroupMetadata::Builder::getMetadata() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline GroupMetadata::Pipeline::getMetadata() { - return ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline(_typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline +GroupMetadata::Pipeline::getMetadata() { + return ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline( + _typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void GroupMetadata::Builder::setMetadata( ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void GroupMetadata::Builder::setMetadata( + ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder GroupMetadata::Builder::initMetadata() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder +GroupMetadata::Builder::initMetadata() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void GroupMetadata::Builder::adoptMetadata( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata>&& + value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata> GroupMetadata::Builder::disownMetadata() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata> +GroupMetadata::Builder::disownMetadata() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool GroupMember::Reader::hasUri() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool GroupMember::Builder::hasUri() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader GroupMember::Reader::getUri() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader GroupMember::Reader::getUri() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder GroupMember::Builder::getUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder GroupMember::Builder::getUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void GroupMember::Builder::setUri( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void GroupMember::Builder::setUri(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder GroupMember::Builder::initUri(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder GroupMember::Builder::initUri(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void GroupMember::Builder::adoptUri( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> GroupMember::Builder::disownUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> GroupMember::Builder::disownUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool GroupMember::Reader::hasType() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool GroupMember::Builder::hasType() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader GroupMember::Reader::getType() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader GroupMember::Reader::getType() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder GroupMember::Builder::getType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder GroupMember::Builder::getType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void GroupMember::Builder::setType( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void GroupMember::Builder::setType(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder GroupMember::Builder::initType(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder GroupMember::Builder::initType( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void GroupMember::Builder::adoptType( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> GroupMember::Builder::disownType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> GroupMember::Builder::disownType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool GroupMember::Reader::getRelative() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool GroupMember::Builder::getRelative() { - return _builder.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void GroupMember::Builder::setRelative(bool value) { - _builder.setDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool GroupMember::Reader::hasName() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool GroupMember::Builder::hasName() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader GroupMember::Reader::getName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader GroupMember::Reader::getName() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder GroupMember::Builder::getName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder GroupMember::Builder::getName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void GroupMember::Builder::setName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void GroupMember::Builder::setName(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder GroupMember::Builder::initName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder GroupMember::Builder::initName( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void GroupMember::Builder::adoptName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> GroupMember::Builder::disownName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> GroupMember::Builder::disownName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool Group::Reader::hasConfig() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool Group::Builder::hasConfig() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader Group::Reader::getConfig() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader +Group::Reader::getConfig() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder Group::Builder::getConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +Group::Builder::getConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline Group::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline +Group::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void Group::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void Group::Builder::setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder Group::Builder::initConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +Group::Builder::initConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void Group::Builder::adoptConfig( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> Group::Builder::disownConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> +Group::Builder::disownConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Group::Reader::hasGroup() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool Group::Builder::hasGroup() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Reader Group::Reader::getGroup() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Group::GroupDetails>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Reader +Group::Reader::getGroup() const { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::Group::GroupDetails>:: + get(_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Builder Group::Builder::getGroup() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Group::GroupDetails>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Builder +Group::Builder::getGroup() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::Group::GroupDetails>:: + get(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Pipeline Group::Pipeline::getGroup() { - return ::tiledb::sm::serialization::capnp::Group::GroupDetails::Pipeline(_typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Pipeline +Group::Pipeline::getGroup() { + return ::tiledb::sm::serialization::capnp::Group::GroupDetails::Pipeline( + _typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void Group::Builder::setGroup( ::tiledb::sm::serialization::capnp::Group::GroupDetails::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Group::GroupDetails>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void Group::Builder::setGroup( + ::tiledb::sm::serialization::capnp::Group::GroupDetails::Reader value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::Group::GroupDetails>:: + set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Builder Group::Builder::initGroup() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Group::GroupDetails>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Group::GroupDetails::Builder +Group::Builder::initGroup() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::Group::GroupDetails>:: + init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void Group::Builder::adoptGroup( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Group::GroupDetails>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Group::GroupDetails>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Group::GroupDetails> Group::Builder::disownGroup() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Group::GroupDetails>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Group::GroupDetails>&& + value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::Group::GroupDetails>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Group::GroupDetails> +Group::Builder::disownGroup() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::Group::GroupDetails>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Group::GroupDetails::Reader::hasMembers() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool Group::GroupDetails::Builder::hasMembers() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Reader Group::GroupDetails::Reader::getMembers() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Builder Group::GroupDetails::Builder::getMembers() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void Group::GroupDetails::Builder::setMembers( ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Builder Group::GroupDetails::Builder::initMembers(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>::Reader +Group::GroupDetails::Reader::getMembers() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>::Builder +Group::GroupDetails::Builder::getMembers() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void Group::GroupDetails::Builder::setMembers( + ::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>::Builder +Group::GroupDetails::Builder::initMembers(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void Group::GroupDetails::Builder::adoptMembers( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>> Group::GroupDetails::Builder::disownMembers() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>> +Group::GroupDetails::Builder::disownMembers() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } inline bool Group::GroupDetails::Reader::hasMetadata() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool Group::GroupDetails::Builder::hasMetadata() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader Group::GroupDetails::Reader::getMetadata() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader +Group::GroupDetails::Reader::getMetadata() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder Group::GroupDetails::Builder::getMetadata() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder +Group::GroupDetails::Builder::getMetadata() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline Group::GroupDetails::Pipeline::getMetadata() { - return ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline(_typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline +Group::GroupDetails::Pipeline::getMetadata() { + return ::tiledb::sm::serialization::capnp::ArrayMetadata::Pipeline( + _typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void Group::GroupDetails::Builder::setMetadata( ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void Group::GroupDetails::Builder::setMetadata( + ::tiledb::sm::serialization::capnp::ArrayMetadata::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder Group::GroupDetails::Builder::initMetadata() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArrayMetadata::Builder +Group::GroupDetails::Builder::initMetadata() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void Group::GroupDetails::Builder::adoptMetadata( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata>&& + value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArrayMetadata> Group::GroupDetails::Builder::disownMetadata() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArrayMetadata>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArrayMetadata> +Group::GroupDetails::Builder::disownMetadata() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArrayMetadata>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool GroupUpdate::Reader::hasConfig() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool GroupUpdate::Builder::hasConfig() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader GroupUpdate::Reader::getConfig() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader +GroupUpdate::Reader::getConfig() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder GroupUpdate::Builder::getConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +GroupUpdate::Builder::getConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline GroupUpdate::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline +GroupUpdate::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void GroupUpdate::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void GroupUpdate::Builder::setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder GroupUpdate::Builder::initConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +GroupUpdate::Builder::initConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void GroupUpdate::Builder::adoptConfig( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> GroupUpdate::Builder::disownConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> +GroupUpdate::Builder::disownConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool GroupUpdate::Reader::hasGroupUpdate() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool GroupUpdate::Builder::hasGroupUpdate() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Reader GroupUpdate::Reader::getGroupUpdate() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Builder GroupUpdate::Builder::getGroupUpdate() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Pipeline GroupUpdate::Pipeline::getGroupUpdate() { - return ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Pipeline(_typeless.getPointerField(1)); -} -#endif // !CAPNP_LITE -inline void GroupUpdate::Builder::setGroupUpdate( ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Builder GroupUpdate::Builder::initGroupUpdate() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: + Reader + GroupUpdate::Reader::getGroupUpdate() const { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>:: + get(_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: + Builder + GroupUpdate::Builder::getGroupUpdate() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>:: + get(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: + Pipeline + GroupUpdate::Pipeline::getGroupUpdate() { + return ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: + Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void GroupUpdate::Builder::setGroupUpdate( + ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails::Reader + value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>:: + set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails:: + Builder + GroupUpdate::Builder::initGroupUpdate() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>:: + init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void GroupUpdate::Builder::adoptGroupUpdate( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails> GroupUpdate::Builder::disownGroupUpdate() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} - -inline bool GroupUpdate::GroupUpdateDetails::Reader::hasMembersToRemove() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>&& + value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails> +GroupUpdate::Builder::disownGroupUpdate() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::GroupUpdate::GroupUpdateDetails>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool GroupUpdate::GroupUpdateDetails::Reader::hasMembersToRemove() + const { + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool GroupUpdate::GroupUpdateDetails::Builder::hasMembersToRemove() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader GroupUpdate::GroupUpdateDetails::Reader::getMembersToRemove() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder GroupUpdate::GroupUpdateDetails::Builder::getMembersToRemove() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void GroupUpdate::GroupUpdateDetails::Builder::setMembersToRemove( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline void GroupUpdate::GroupUpdateDetails::Builder::setMembersToRemove(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder GroupUpdate::GroupUpdateDetails::Builder::initMembersToRemove(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +GroupUpdate::GroupUpdateDetails::Reader::getMembersToRemove() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +GroupUpdate::GroupUpdateDetails::Builder::getMembersToRemove() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void GroupUpdate::GroupUpdateDetails::Builder::setMembersToRemove( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline void GroupUpdate::GroupUpdateDetails::Builder::setMembersToRemove( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +GroupUpdate::GroupUpdateDetails::Builder::initMembersToRemove( + unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void GroupUpdate::GroupUpdateDetails::Builder::adoptMembersToRemove( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> GroupUpdate::GroupUpdateDetails::Builder::disownMembersToRemove() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +GroupUpdate::GroupUpdateDetails::Builder::disownMembersToRemove() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool GroupUpdate::GroupUpdateDetails::Reader::hasMembersToAdd() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool GroupUpdate::GroupUpdateDetails::Builder::hasMembersToAdd() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Reader GroupUpdate::GroupUpdateDetails::Reader::getMembersToAdd() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Builder GroupUpdate::GroupUpdateDetails::Builder::getMembersToAdd() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void GroupUpdate::GroupUpdateDetails::Builder::setMembersToAdd( ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>::Builder GroupUpdate::GroupUpdateDetails::Builder::initMembersToAdd(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>::Reader +GroupUpdate::GroupUpdateDetails::Reader::getMembersToAdd() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>::Builder +GroupUpdate::GroupUpdateDetails::Builder::getMembersToAdd() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); +} +inline void GroupUpdate::GroupUpdateDetails::Builder::setMembersToAdd( + ::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>::Builder +GroupUpdate::GroupUpdateDetails::Builder::initMembersToAdd(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void GroupUpdate::GroupUpdateDetails::Builder::adoptMembersToAdd( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>> GroupUpdate::GroupUpdateDetails::Builder::disownMembersToAdd() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::GroupMember, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>> +GroupUpdate::GroupUpdateDetails::Builder::disownMembersToAdd() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::GroupMember, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<1>() * + ::capnp::POINTERS)); } inline bool GroupCreate::Reader::hasConfig() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool GroupCreate::Builder::hasConfig() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader GroupCreate::Reader::getConfig() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader +GroupCreate::Reader::getConfig() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder GroupCreate::Builder::getConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +GroupCreate::Builder::getConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline GroupCreate::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline +GroupCreate::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void GroupCreate::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void GroupCreate::Builder::setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder GroupCreate::Builder::initConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +GroupCreate::Builder::initConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void GroupCreate::Builder::adoptConfig( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> GroupCreate::Builder::disownConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> +GroupCreate::Builder::disownConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool GroupCreate::Reader::hasGroupDetails() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool GroupCreate::Builder::hasGroupDetails() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Reader GroupCreate::Reader::getGroupDetails() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Builder GroupCreate::Builder::getGroupDetails() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Pipeline GroupCreate::Pipeline::getGroupDetails() { - return ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Pipeline(_typeless.getPointerField(1)); -} -#endif // !CAPNP_LITE -inline void GroupCreate::Builder::setGroupDetails( ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Builder GroupCreate::Builder::initGroupDetails() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: + Reader + GroupCreate::Reader::getGroupDetails() const { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>:: + get(_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: + Builder + GroupCreate::Builder::getGroupDetails() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>:: + get(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: + Pipeline + GroupCreate::Pipeline::getGroupDetails() { + return ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: + Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void GroupCreate::Builder::setGroupDetails( + ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails::Reader + value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>:: + set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails:: + Builder + GroupCreate::Builder::initGroupDetails() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>:: + init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void GroupCreate::Builder::adoptGroupDetails( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails> GroupCreate::Builder::disownGroupDetails() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>&& + value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails> +GroupCreate::Builder::disownGroupDetails() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::GroupCreate::GroupCreateDetails>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool GroupCreate::GroupCreateDetails::Reader::hasUri() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool GroupCreate::GroupCreateDetails::Builder::hasUri() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::Text::Reader GroupCreate::GroupCreateDetails::Reader::getUri() + const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder +GroupCreate::GroupCreateDetails::Builder::getUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void GroupCreate::GroupCreateDetails::Builder::setUri( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::Text::Builder GroupCreate::GroupCreateDetails::Builder::initUri( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } -inline ::capnp::Text::Reader GroupCreate::GroupCreateDetails::Reader::getUri() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder GroupCreate::GroupCreateDetails::Builder::getUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline void GroupCreate::GroupCreateDetails::Builder::adoptUri( + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline void GroupCreate::GroupCreateDetails::Builder::setUri( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::Text::Builder GroupCreate::GroupCreateDetails::Builder::initUri(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); -} -inline void GroupCreate::GroupCreateDetails::Builder::adoptUri( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::Text> GroupCreate::GroupCreateDetails::Builder::disownUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +GroupCreate::GroupCreateDetails::Builder::disownUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool GlobalWriteState::Reader::hasCellsWritten() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool GlobalWriteState::Builder::hasCellsWritten() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::MapUInt64::Reader GlobalWriteState::Reader::getCellsWritten() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapUInt64::Reader +GlobalWriteState::Reader::getCellsWritten() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder GlobalWriteState::Builder::getCellsWritten() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder +GlobalWriteState::Builder::getCellsWritten() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline GlobalWriteState::Pipeline::getCellsWritten() { - return ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline +GlobalWriteState::Pipeline::getCellsWritten() { + return ::tiledb::sm::serialization::capnp::MapUInt64::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void GlobalWriteState::Builder::setCellsWritten( ::tiledb::sm::serialization::capnp::MapUInt64::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void GlobalWriteState::Builder::setCellsWritten( + ::tiledb::sm::serialization::capnp::MapUInt64::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder GlobalWriteState::Builder::initCellsWritten() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapUInt64::Builder +GlobalWriteState::Builder::initCellsWritten() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void GlobalWriteState::Builder::adoptCellsWritten( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapUInt64>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapUInt64>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapUInt64> GlobalWriteState::Builder::disownCellsWritten() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapUInt64>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapUInt64> +GlobalWriteState::Builder::disownCellsWritten() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::MapUInt64>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool GlobalWriteState::Reader::hasFragMeta() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool GlobalWriteState::Builder::hasFragMeta() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader GlobalWriteState::Reader::getFragMeta() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader +GlobalWriteState::Reader::getFragMeta() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder GlobalWriteState::Builder::getFragMeta() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder +GlobalWriteState::Builder::getFragMeta() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline GlobalWriteState::Pipeline::getFragMeta() { - return ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline(_typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline +GlobalWriteState::Pipeline::getFragMeta() { + return ::tiledb::sm::serialization::capnp::FragmentMetadata::Pipeline( + _typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void GlobalWriteState::Builder::setFragMeta( ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void GlobalWriteState::Builder::setFragMeta( + ::tiledb::sm::serialization::capnp::FragmentMetadata::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::FragmentMetadata>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder GlobalWriteState::Builder::initFragMeta() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::FragmentMetadata::Builder +GlobalWriteState::Builder::initFragMeta() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::FragmentMetadata>:: + init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void GlobalWriteState::Builder::adoptFragMeta( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata> GlobalWriteState::Builder::disownFragMeta() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata>&& + value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::FragmentMetadata>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata> +GlobalWriteState::Builder::disownFragMeta() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::FragmentMetadata>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool GlobalWriteState::Reader::hasLastCellCoords() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool GlobalWriteState::Builder::hasLastCellCoords() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::SingleCoord::Reader GlobalWriteState::Reader::getLastCellCoords() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SingleCoord>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SingleCoord::Reader +GlobalWriteState::Reader::getLastCellCoords() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::SingleCoord>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::SingleCoord::Builder GlobalWriteState::Builder::getLastCellCoords() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SingleCoord>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SingleCoord::Builder +GlobalWriteState::Builder::getLastCellCoords() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::SingleCoord>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::SingleCoord::Pipeline GlobalWriteState::Pipeline::getLastCellCoords() { - return ::tiledb::sm::serialization::capnp::SingleCoord::Pipeline(_typeless.getPointerField(2)); +inline ::tiledb::sm::serialization::capnp::SingleCoord::Pipeline +GlobalWriteState::Pipeline::getLastCellCoords() { + return ::tiledb::sm::serialization::capnp::SingleCoord::Pipeline( + _typeless.getPointerField(2)); } #endif // !CAPNP_LITE -inline void GlobalWriteState::Builder::setLastCellCoords( ::tiledb::sm::serialization::capnp::SingleCoord::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SingleCoord>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void GlobalWriteState::Builder::setLastCellCoords( + ::tiledb::sm::serialization::capnp::SingleCoord::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::SingleCoord>:: + set(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::SingleCoord::Builder GlobalWriteState::Builder::initLastCellCoords() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SingleCoord>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::SingleCoord::Builder +GlobalWriteState::Builder::initLastCellCoords() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::SingleCoord>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline void GlobalWriteState::Builder::adoptLastCellCoords( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SingleCoord>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SingleCoord>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::SingleCoord>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::SingleCoord>:: + adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::SingleCoord> GlobalWriteState::Builder::disownLastCellCoords() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::SingleCoord>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::SingleCoord> +GlobalWriteState::Builder::disownLastCellCoords() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::SingleCoord>::disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::uint64_t GlobalWriteState::Reader::getLastHilbertValue() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t GlobalWriteState::Reader::getLastHilbertValue() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t GlobalWriteState::Builder::getLastHilbertValue() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t GlobalWriteState::Builder::getLastHilbertValue() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void GlobalWriteState::Builder::setLastHilbertValue( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void GlobalWriteState::Builder::setLastHilbertValue(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool GlobalWriteState::Reader::hasMultiPartUploadStates() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool GlobalWriteState::Builder::hasMultiPartUploadStates() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Reader GlobalWriteState::Reader::getMultiPartUploadStates() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Builder GlobalWriteState::Builder::getMultiPartUploadStates() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Pipeline GlobalWriteState::Pipeline::getMultiPartUploadStates() { - return ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Pipeline(_typeless.getPointerField(3)); -} -#endif // !CAPNP_LITE -inline void GlobalWriteState::Builder::setMultiPartUploadStates( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Builder GlobalWriteState::Builder::initMultiPartUploadStates() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); +} +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Reader +GlobalWriteState::Reader::getMultiPartUploadStates() const { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>>:: + get(_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Builder +GlobalWriteState::Builder::getMultiPartUploadStates() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>>:: + get(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Pipeline +GlobalWriteState::Pipeline::getMultiPartUploadStates() { + return ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>:: + Pipeline(_typeless.getPointerField(3)); +} +#endif // !CAPNP_LITE +inline void GlobalWriteState::Builder::setMultiPartUploadStates( + ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Reader + value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>>:: + set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>::Builder +GlobalWriteState::Builder::initMultiPartUploadStates() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>>:: + init(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline void GlobalWriteState::Builder::adoptMultiPartUploadStates( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>> GlobalWriteState::Builder::disownMultiPartUploadStates() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::MultiPartUploadState>>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>>:: + adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>> +GlobalWriteState::Builder::disownMultiPartUploadStates() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::MultiPartUploadState>>:: + disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool SingleCoord::Reader::hasCoords() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool SingleCoord::Builder::hasCoords() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader SingleCoord::Reader::getCoords() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder SingleCoord::Builder::getCoords() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void SingleCoord::Builder::setCoords( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline void SingleCoord::Builder::setCoords(::kj::ArrayPtr::Reader> value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder SingleCoord::Builder::initCoords(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader +SingleCoord::Reader::getCoords() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +SingleCoord::Builder::getCoords() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void SingleCoord::Builder::setCoords( + ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline void SingleCoord::Builder::setCoords( + ::kj::ArrayPtr< + const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> + value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +SingleCoord::Builder::initCoords(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void SingleCoord::Builder::adoptCoords( - ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> SingleCoord::Builder::disownCoords() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> +SingleCoord::Builder::disownCoords() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } inline bool SingleCoord::Reader::hasSizes() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool SingleCoord::Builder::hasSizes() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader SingleCoord::Reader::getSizes() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder SingleCoord::Builder::getSizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void SingleCoord::Builder::setSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline void SingleCoord::Builder::setSizes(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder SingleCoord::Builder::initSizes(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +SingleCoord::Reader::getSizes() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +SingleCoord::Builder::getSizes() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void SingleCoord::Builder::setSizes( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline void SingleCoord::Builder::setSizes( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +SingleCoord::Builder::initSizes(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void SingleCoord::Builder::adoptSizes( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> SingleCoord::Builder::disownSizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +SingleCoord::Builder::disownSizes() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool SingleCoord::Reader::hasSingleOffset() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool SingleCoord::Builder::hasSingleOffset() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader SingleCoord::Reader::getSingleOffset() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder SingleCoord::Builder::getSingleOffset() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void SingleCoord::Builder::setSingleOffset( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline void SingleCoord::Builder::setSingleOffset(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder SingleCoord::Builder::initSingleOffset(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +SingleCoord::Reader::getSingleOffset() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +SingleCoord::Builder::getSingleOffset() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void SingleCoord::Builder::setSingleOffset( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline void SingleCoord::Builder::setSingleOffset( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +SingleCoord::Builder::initSingleOffset(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void SingleCoord::Builder::adoptSingleOffset( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> SingleCoord::Builder::disownSingleOffset() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +SingleCoord::Builder::disownSingleOffset() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasFileSizes() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasFileSizes() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::Reader::getFileSizes() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::getFileSizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setFileSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setFileSizes(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::initFileSizes(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +FragmentMetadata::Reader::getFileSizes() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::Builder::getFileSizes() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setFileSizes( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setFileSizes( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::Builder::initFileSizes(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptFileSizes( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::Builder::disownFileSizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +FragmentMetadata::Builder::disownFileSizes() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasFileVarSizes() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasFileVarSizes() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::Reader::getFileVarSizes() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::getFileVarSizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setFileVarSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setFileVarSizes(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::initFileVarSizes(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +FragmentMetadata::Reader::getFileVarSizes() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::Builder::getFileVarSizes() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setFileVarSizes( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setFileVarSizes( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::Builder::initFileVarSizes(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptFileVarSizes( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::Builder::disownFileVarSizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +FragmentMetadata::Builder::disownFileVarSizes() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasFileValiditySizes() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasFileValiditySizes() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::Reader::getFileValiditySizes() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::getFileValiditySizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setFileValiditySizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setFileValiditySizes(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::initFileValiditySizes(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +FragmentMetadata::Reader::getFileValiditySizes() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::Builder::getFileValiditySizes() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setFileValiditySizes( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setFileValiditySizes( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::Builder::initFileValiditySizes(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptFileValiditySizes( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::Builder::disownFileValiditySizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +FragmentMetadata::Builder::disownFileValiditySizes() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasFragmentUri() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasFragmentUri() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader FragmentMetadata::Reader::getFragmentUri() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader FragmentMetadata::Reader::getFragmentUri() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder FragmentMetadata::Builder::getFragmentUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder FragmentMetadata::Builder::getFragmentUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } -inline void FragmentMetadata::Builder::setFragmentUri( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); +inline void FragmentMetadata::Builder::setFragmentUri( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder FragmentMetadata::Builder::initFragmentUri(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder FragmentMetadata::Builder::initFragmentUri( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptFragmentUri( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> FragmentMetadata::Builder::disownFragmentUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +FragmentMetadata::Builder::disownFragmentUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::getHasTimestamps() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool FragmentMetadata::Builder::getHasTimestamps() { - return _builder.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void FragmentMetadata::Builder::setHasTimestamps(bool value) { - _builder.setDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool FragmentMetadata::Reader::getHasDeleteMeta() const { - return _reader.getDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline bool FragmentMetadata::Builder::getHasDeleteMeta() { - return _builder.getDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS); } inline void FragmentMetadata::Builder::setHasDeleteMeta(bool value) { - _builder.setDataField( - ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t FragmentMetadata::Reader::getSparseTileNum() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t FragmentMetadata::Reader::getSparseTileNum() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t FragmentMetadata::Builder::getSparseTileNum() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t FragmentMetadata::Builder::getSparseTileNum() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void FragmentMetadata::Builder::setSparseTileNum( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void FragmentMetadata::Builder::setSparseTileNum(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t FragmentMetadata::Reader::getTileIndexBase() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t FragmentMetadata::Reader::getTileIndexBase() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t FragmentMetadata::Builder::getTileIndexBase() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t FragmentMetadata::Builder::getTileIndexBase() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void FragmentMetadata::Builder::setTileIndexBase( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void FragmentMetadata::Builder::setTileIndexBase(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool FragmentMetadata::Reader::hasTileOffsets() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasTileOffsets() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileOffsets() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileOffsets( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setTileOffsets(::kj::ArrayPtr::Reader> value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileOffsets(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader +FragmentMetadata::Reader::getTileOffsets() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_reader + .getPointerField( + ::capnp::bounded<4>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::getTileOffsets() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_builder + .getPointerField( + ::capnp::bounded<4>() * + ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileOffsets( + ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setTileOffsets( + ::kj::ArrayPtr< + const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> + value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::initTileOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + init( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptTileOffsets( - ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> +FragmentMetadata::Builder::disownTileOffsets() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::disown(_builder + .getPointerField( + ::capnp::bounded<4>() * + ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileVarOffsets() const { - return !_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasTileVarOffsets() { - return !_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileVarOffsets() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileVarOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileVarOffsets( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setTileVarOffsets(::kj::ArrayPtr::Reader> value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileVarOffsets(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader +FragmentMetadata::Reader::getTileVarOffsets() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_reader + .getPointerField( + ::capnp::bounded<5>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::getTileVarOffsets() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_builder + .getPointerField( + ::capnp::bounded<5>() * + ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileVarOffsets( + ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setTileVarOffsets( + ::kj::ArrayPtr< + const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> + value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::initTileVarOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + init( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptTileVarOffsets( - ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileVarOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + adopt( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> +FragmentMetadata::Builder::disownTileVarOffsets() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::disown(_builder + .getPointerField( + ::capnp::bounded<5>() * + ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileVarSizes() const { - return !_reader.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasTileVarSizes() { - return !_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileVarSizes() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileVarSizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileVarSizes( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setTileVarSizes(::kj::ArrayPtr::Reader> value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileVarSizes(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader +FragmentMetadata::Reader::getTileVarSizes() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_reader + .getPointerField( + ::capnp::bounded<6>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::getTileVarSizes() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_builder + .getPointerField( + ::capnp::bounded<6>() * + ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileVarSizes( + ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setTileVarSizes( + ::kj::ArrayPtr< + const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> + value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::initTileVarSizes(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + init( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptTileVarSizes( - ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileVarSizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + adopt( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> +FragmentMetadata::Builder::disownTileVarSizes() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::disown(_builder + .getPointerField( + ::capnp::bounded<6>() * + ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileValidityOffsets() const { - return !_reader.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasTileValidityOffsets() { - return !_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileValidityOffsets() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileValidityOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileValidityOffsets( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setTileValidityOffsets(::kj::ArrayPtr::Reader> value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileValidityOffsets(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader +FragmentMetadata::Reader::getTileValidityOffsets() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_reader + .getPointerField( + ::capnp::bounded<7>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::getTileValidityOffsets() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_builder + .getPointerField( + ::capnp::bounded<7>() * + ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileValidityOffsets( + ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setTileValidityOffsets( + ::kj::ArrayPtr< + const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> + value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::initTileValidityOffsets(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + init( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptTileValidityOffsets( - ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileValidityOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + adopt( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> +FragmentMetadata::Builder::disownTileValidityOffsets() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::disown(_builder + .getPointerField( + ::capnp::bounded<7>() * + ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileMinBuffer() const { - return !_reader.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasTileMinBuffer() { - return !_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileMinBuffer() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileMinBuffer() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileMinBuffer( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setTileMinBuffer(::kj::ArrayPtr::Reader> value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileMinBuffer(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader +FragmentMetadata::Reader::getTileMinBuffer() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_reader + .getPointerField( + ::capnp::bounded<8>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::getTileMinBuffer() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_builder + .getPointerField( + ::capnp::bounded<8>() * + ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileMinBuffer( + ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setTileMinBuffer( + ::kj::ArrayPtr< + const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> + value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::initTileMinBuffer(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + init( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptTileMinBuffer( - ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileMinBuffer() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( - ::capnp::bounded<8>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + adopt( + _builder.getPointerField(::capnp::bounded<8>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> +FragmentMetadata::Builder::disownTileMinBuffer() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::disown(_builder + .getPointerField( + ::capnp::bounded<8>() * + ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileMinVarBuffer() const { - return !_reader.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasTileMinVarBuffer() { - return !_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileMinVarBuffer() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileMinVarBuffer() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileMinVarBuffer( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setTileMinVarBuffer(::kj::ArrayPtr::Reader> value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileMinVarBuffer(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader +FragmentMetadata::Reader::getTileMinVarBuffer() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_reader + .getPointerField( + ::capnp::bounded<9>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::getTileMinVarBuffer() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_builder + .getPointerField( + ::capnp::bounded<9>() * + ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileMinVarBuffer( + ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setTileMinVarBuffer( + ::kj::ArrayPtr< + const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> + value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::initTileMinVarBuffer(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + init( + _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptTileMinVarBuffer( - ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileMinVarBuffer() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( - ::capnp::bounded<9>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + adopt( + _builder.getPointerField(::capnp::bounded<9>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> +FragmentMetadata::Builder::disownTileMinVarBuffer() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::disown(_builder + .getPointerField( + ::capnp::bounded<9>() * + ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileMaxBuffer() const { - return !_reader.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasTileMaxBuffer() { - return !_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileMaxBuffer() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileMaxBuffer() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileMaxBuffer( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setTileMaxBuffer(::kj::ArrayPtr::Reader> value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileMaxBuffer(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader +FragmentMetadata::Reader::getTileMaxBuffer() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_reader + .getPointerField( + ::capnp::bounded<10>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::getTileMaxBuffer() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_builder + .getPointerField( + ::capnp::bounded<10>() * + ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileMaxBuffer( + ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setTileMaxBuffer( + ::kj::ArrayPtr< + const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> + value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::initTileMaxBuffer(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + init( + _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptTileMaxBuffer( - ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileMaxBuffer() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( - ::capnp::bounded<10>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + adopt( + _builder.getPointerField(::capnp::bounded<10>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> +FragmentMetadata::Builder::disownTileMaxBuffer() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::disown(_builder + .getPointerField( + ::capnp::bounded<10>() * + ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileMaxVarBuffer() const { - return !_reader.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasTileMaxVarBuffer() { - return !_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileMaxVarBuffer() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileMaxVarBuffer() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileMaxVarBuffer( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setTileMaxVarBuffer(::kj::ArrayPtr::Reader> value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileMaxVarBuffer(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader +FragmentMetadata::Reader::getTileMaxVarBuffer() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_reader + .getPointerField( + ::capnp::bounded<11>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::getTileMaxVarBuffer() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_builder + .getPointerField( + ::capnp::bounded<11>() * + ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileMaxVarBuffer( + ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setTileMaxVarBuffer( + ::kj::ArrayPtr< + const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> + value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::initTileMaxVarBuffer(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + init( + _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptTileMaxVarBuffer( - ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileMaxVarBuffer() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( - ::capnp::bounded<11>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + adopt( + _builder.getPointerField(::capnp::bounded<11>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> +FragmentMetadata::Builder::disownTileMaxVarBuffer() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::disown(_builder + .getPointerField( + ::capnp::bounded<11>() * + ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileSums() const { - return !_reader.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasTileSums() { - return !_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileSums() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileSums() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileSums( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setTileSums(::kj::ArrayPtr::Reader> value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileSums(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader +FragmentMetadata::Reader::getTileSums() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_reader + .getPointerField( + ::capnp::bounded<12>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::getTileSums() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_builder + .getPointerField( + ::capnp::bounded<12>() * + ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileSums( + ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setTileSums( + ::kj::ArrayPtr< + const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> + value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::initTileSums(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + init( + _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptTileSums( - ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileSums() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( - ::capnp::bounded<12>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + adopt( + _builder.getPointerField(::capnp::bounded<12>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> +FragmentMetadata::Builder::disownTileSums() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::disown(_builder + .getPointerField( + ::capnp::bounded<12>() * + ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasTileNullCounts() const { - return !_reader.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasTileNullCounts() { - return !_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getTileNullCounts() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getTileNullCounts() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTileNullCounts( ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setTileNullCounts(::kj::ArrayPtr::Reader> value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initTileNullCounts(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader +FragmentMetadata::Reader::getTileNullCounts() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_reader + .getPointerField( + ::capnp::bounded<13>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::getTileNullCounts() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_builder + .getPointerField( + ::capnp::bounded<13>() * + ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTileNullCounts( + ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setTileNullCounts( + ::kj::ArrayPtr< + const ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader> + value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::initTileNullCounts(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + init( + _builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptTileNullCounts( - ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownTileNullCounts() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( - ::capnp::bounded<13>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + adopt( + _builder.getPointerField(::capnp::bounded<13>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> +FragmentMetadata::Builder::disownTileNullCounts() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::disown(_builder + .getPointerField( + ::capnp::bounded<13>() * + ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasFragmentMins() const { - return !_reader.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasFragmentMins() { - return !_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getFragmentMins() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getFragmentMins() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setFragmentMins( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setFragmentMins(::kj::ArrayPtr::Reader> value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initFragmentMins(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader +FragmentMetadata::Reader::getFragmentMins() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_reader + .getPointerField( + ::capnp::bounded<14>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::getFragmentMins() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_builder + .getPointerField( + ::capnp::bounded<14>() * + ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setFragmentMins( + ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setFragmentMins( + ::kj::ArrayPtr< + const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> + value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::initFragmentMins(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + init( + _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptFragmentMins( - ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownFragmentMins() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( - ::capnp::bounded<14>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + adopt( + _builder.getPointerField(::capnp::bounded<14>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> +FragmentMetadata::Builder::disownFragmentMins() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::disown(_builder + .getPointerField( + ::capnp::bounded<14>() * + ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasFragmentMaxs() const { - return !_reader.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasFragmentMaxs() { - return !_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader FragmentMetadata::Reader::getFragmentMaxs() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::getFragmentMaxs() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setFragmentMaxs( ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setFragmentMaxs(::kj::ArrayPtr::Reader> value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>::Builder FragmentMetadata::Builder::initFragmentMaxs(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader +FragmentMetadata::Reader::getFragmentMaxs() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_reader + .getPointerField( + ::capnp::bounded<15>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::getFragmentMaxs() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::get(_builder + .getPointerField( + ::capnp::bounded<15>() * + ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setFragmentMaxs( + ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setFragmentMaxs( + ::kj::ArrayPtr< + const ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>::Reader> + value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>::Builder +FragmentMetadata::Builder::initFragmentMaxs(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + init( + _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptFragmentMaxs( - ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>> FragmentMetadata::Builder::disownFragmentMaxs() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::uint8_t, ::capnp::Kind::PRIMITIVE>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( - ::capnp::bounded<15>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>:: + adopt( + _builder.getPointerField(::capnp::bounded<15>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>> +FragmentMetadata::Builder::disownFragmentMaxs() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::uint8_t, ::capnp::Kind::PRIMITIVE>, + ::capnp::Kind::LIST>>::disown(_builder + .getPointerField( + ::capnp::bounded<15>() * + ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasFragmentSums() const { - return !_reader.getPointerField( - ::capnp::bounded<16>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasFragmentSums() { - return !_builder.getPointerField( - ::capnp::bounded<16>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::Reader::getFragmentSums() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<16>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::getFragmentSums() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<16>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setFragmentSums( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<16>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setFragmentSums(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<16>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::initFragmentSums(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<16>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +FragmentMetadata::Reader::getFragmentSums() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::Builder::getFragmentSums() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setFragmentSums( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setFragmentSums( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::Builder::initFragmentSums(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptFragmentSums( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<16>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::Builder::disownFragmentSums() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<16>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +FragmentMetadata::Builder::disownFragmentSums() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<16>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasFragmentNullCounts() const { - return !_reader.getPointerField( - ::capnp::bounded<17>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasFragmentNullCounts() { - return !_builder.getPointerField( - ::capnp::bounded<17>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::Reader::getFragmentNullCounts() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<17>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::getFragmentNullCounts() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<17>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setFragmentNullCounts( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<17>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setFragmentNullCounts(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<17>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::initFragmentNullCounts(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<17>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +FragmentMetadata::Reader::getFragmentNullCounts() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::Builder::getFragmentNullCounts() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setFragmentNullCounts( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setFragmentNullCounts( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::Builder::initFragmentNullCounts(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptFragmentNullCounts( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<17>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::Builder::disownFragmentNullCounts() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<17>() * ::capnp::POINTERS)); -} - -inline ::uint32_t FragmentMetadata::Reader::getVersion() const { - return _reader.getDataField< ::uint32_t>( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +FragmentMetadata::Builder::disownFragmentNullCounts() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<17>() * ::capnp::POINTERS)); +} + +inline ::uint32_t FragmentMetadata::Reader::getVersion() const { + return _reader.getDataField<::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint32_t FragmentMetadata::Builder::getVersion() { - return _builder.getDataField< ::uint32_t>( +inline ::uint32_t FragmentMetadata::Builder::getVersion() { + return _builder.getDataField<::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void FragmentMetadata::Builder::setVersion( ::uint32_t value) { - _builder.setDataField< ::uint32_t>( +inline void FragmentMetadata::Builder::setVersion(::uint32_t value) { + _builder.setDataField<::uint32_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool FragmentMetadata::Reader::hasTimestampRange() const { - return !_reader.getPointerField( - ::capnp::bounded<18>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasTimestampRange() { - return !_builder.getPointerField( - ::capnp::bounded<18>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::Reader::getTimestampRange() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<18>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::getTimestampRange() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<18>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setTimestampRange( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<18>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::Builder::setTimestampRange(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<18>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::Builder::initTimestampRange(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<18>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +FragmentMetadata::Reader::getTimestampRange() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::Builder::getTimestampRange() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setTimestampRange( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::Builder::setTimestampRange( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::Builder::initTimestampRange(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptTimestampRange( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<18>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::Builder::disownTimestampRange() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<18>() * ::capnp::POINTERS)); -} - -inline ::uint64_t FragmentMetadata::Reader::getLastTileCellNum() const { - return _reader.getDataField< ::uint64_t>( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +FragmentMetadata::Builder::disownTimestampRange() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<18>() * ::capnp::POINTERS)); +} + +inline ::uint64_t FragmentMetadata::Reader::getLastTileCellNum() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS); } -inline ::uint64_t FragmentMetadata::Builder::getLastTileCellNum() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t FragmentMetadata::Builder::getLastTileCellNum() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS); } -inline void FragmentMetadata::Builder::setLastTileCellNum( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void FragmentMetadata::Builder::setLastTileCellNum(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<3>() * ::capnp::ELEMENTS, value); } inline bool FragmentMetadata::Reader::hasNonEmptyDomain() const { - return !_reader.getPointerField( - ::capnp::bounded<19>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<19>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasNonEmptyDomain() { - return !_builder.getPointerField( - ::capnp::bounded<19>() * ::capnp::POINTERS).isNull(); -} -inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader FragmentMetadata::Reader::getNonEmptyDomain() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::get(_reader.getPointerField( - ::capnp::bounded<19>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder FragmentMetadata::Builder::getNonEmptyDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::get(_builder.getPointerField( - ::capnp::bounded<19>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline FragmentMetadata::Pipeline::getNonEmptyDomain() { - return ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline(_typeless.getPointerField(19)); -} -#endif // !CAPNP_LITE -inline void FragmentMetadata::Builder::setNonEmptyDomain( ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::set(_builder.getPointerField( - ::capnp::bounded<19>() * ::capnp::POINTERS), value); -} -inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder FragmentMetadata::Builder::initNonEmptyDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::init(_builder.getPointerField( - ::capnp::bounded<19>() * ::capnp::POINTERS)); + return !_builder.getPointerField(::capnp::bounded<19>() * ::capnp::POINTERS) + .isNull(); +} +inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader +FragmentMetadata::Reader::getNonEmptyDomain() const { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: + get(_reader.getPointerField(::capnp::bounded<19>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder +FragmentMetadata::Builder::getNonEmptyDomain() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: + get(_builder.getPointerField(::capnp::bounded<19>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline +FragmentMetadata::Pipeline::getNonEmptyDomain() { + return ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Pipeline( + _typeless.getPointerField(19)); +} +#endif // !CAPNP_LITE +inline void FragmentMetadata::Builder::setNonEmptyDomain( + ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Reader value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: + set(_builder.getPointerField(::capnp::bounded<19>() * ::capnp::POINTERS), + value); +} +inline ::tiledb::sm::serialization::capnp::NonEmptyDomainList::Builder +FragmentMetadata::Builder::initNonEmptyDomain() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: + init( + _builder.getPointerField(::capnp::bounded<19>() * ::capnp::POINTERS)); } inline void FragmentMetadata::Builder::adoptNonEmptyDomain( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::adopt(_builder.getPointerField( - ::capnp::bounded<19>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NonEmptyDomainList> FragmentMetadata::Builder::disownNonEmptyDomain() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NonEmptyDomainList>::disown(_builder.getPointerField( - ::capnp::bounded<19>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::NonEmptyDomainList>&& + value) { + ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: + adopt( + _builder.getPointerField(::capnp::bounded<19>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::NonEmptyDomainList> +FragmentMetadata::Builder::disownNonEmptyDomain() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::NonEmptyDomainList>:: + disown( + _builder.getPointerField(::capnp::bounded<19>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasRtree() const { - return !_reader.getPointerField( - ::capnp::bounded<20>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<20>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasRtree() { - return !_builder.getPointerField( - ::capnp::bounded<20>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<20>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Data::Reader FragmentMetadata::Reader::getRtree() const { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField( - ::capnp::bounded<20>() * ::capnp::POINTERS)); +inline ::capnp::Data::Reader FragmentMetadata::Reader::getRtree() const { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _reader.getPointerField(::capnp::bounded<20>() * ::capnp::POINTERS)); } -inline ::capnp::Data::Builder FragmentMetadata::Builder::getRtree() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField( - ::capnp::bounded<20>() * ::capnp::POINTERS)); +inline ::capnp::Data::Builder FragmentMetadata::Builder::getRtree() { + return ::capnp::_::PointerHelpers<::capnp::Data>::get( + _builder.getPointerField(::capnp::bounded<20>() * ::capnp::POINTERS)); } -inline void FragmentMetadata::Builder::setRtree( ::capnp::Data::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField( - ::capnp::bounded<20>() * ::capnp::POINTERS), value); +inline void FragmentMetadata::Builder::setRtree(::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Data>::set( + _builder.getPointerField(::capnp::bounded<20>() * ::capnp::POINTERS), + value); } -inline ::capnp::Data::Builder FragmentMetadata::Builder::initRtree(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField( - ::capnp::bounded<20>() * ::capnp::POINTERS), size); +inline ::capnp::Data::Builder FragmentMetadata::Builder::initRtree( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Data>::init( + _builder.getPointerField(::capnp::bounded<20>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptRtree( - ::capnp::Orphan< ::capnp::Data>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField( - ::capnp::bounded<20>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Data>&& value) { + ::capnp::_::PointerHelpers<::capnp::Data>::adopt( + _builder.getPointerField(::capnp::bounded<20>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Data> FragmentMetadata::Builder::disownRtree() { - return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField( - ::capnp::bounded<20>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Data> FragmentMetadata::Builder::disownRtree() { + return ::capnp::_::PointerHelpers<::capnp::Data>::disown( + _builder.getPointerField(::capnp::bounded<20>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::getHasConsolidatedFooter() const { - return _reader.getDataField( - ::capnp::bounded<2>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS); } inline bool FragmentMetadata::Builder::getHasConsolidatedFooter() { - return _builder.getDataField( - ::capnp::bounded<2>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS); } inline void FragmentMetadata::Builder::setHasConsolidatedFooter(bool value) { - _builder.setDataField( - ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } inline bool FragmentMetadata::Reader::hasGtOffsets() const { - return !_reader.getPointerField( - ::capnp::bounded<21>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<21>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasGtOffsets() { - return !_builder.getPointerField( - ::capnp::bounded<21>() * ::capnp::POINTERS).isNull(); -} -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Reader FragmentMetadata::Reader::getGtOffsets() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets>::get(_reader.getPointerField( - ::capnp::bounded<21>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Builder FragmentMetadata::Builder::getGtOffsets() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets>::get(_builder.getPointerField( - ::capnp::bounded<21>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Pipeline FragmentMetadata::Pipeline::getGtOffsets() { - return ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Pipeline(_typeless.getPointerField(21)); -} -#endif // !CAPNP_LITE -inline void FragmentMetadata::Builder::setGtOffsets( ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets>::set(_builder.getPointerField( - ::capnp::bounded<21>() * ::capnp::POINTERS), value); -} -inline ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets::Builder FragmentMetadata::Builder::initGtOffsets() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets>::init(_builder.getPointerField( - ::capnp::bounded<21>() * ::capnp::POINTERS)); + return !_builder.getPointerField(::capnp::bounded<21>() * ::capnp::POINTERS) + .isNull(); +} +inline ::tiledb::sm::serialization::capnp::FragmentMetadata:: + GenericTileOffsets::Reader + FragmentMetadata::Reader::getGtOffsets() const { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp:: + FragmentMetadata::GenericTileOffsets>:: + get(_reader.getPointerField(::capnp::bounded<21>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::FragmentMetadata:: + GenericTileOffsets::Builder + FragmentMetadata::Builder::getGtOffsets() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp:: + FragmentMetadata::GenericTileOffsets>:: + get(_builder.getPointerField(::capnp::bounded<21>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::FragmentMetadata:: + GenericTileOffsets::Pipeline + FragmentMetadata::Pipeline::getGtOffsets() { + return ::tiledb::sm::serialization::capnp::FragmentMetadata:: + GenericTileOffsets::Pipeline(_typeless.getPointerField(21)); +} +#endif // !CAPNP_LITE +inline void FragmentMetadata::Builder::setGtOffsets( + ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets:: + Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp:: + FragmentMetadata::GenericTileOffsets>:: + set(_builder.getPointerField(::capnp::bounded<21>() * ::capnp::POINTERS), + value); +} +inline ::tiledb::sm::serialization::capnp::FragmentMetadata:: + GenericTileOffsets::Builder + FragmentMetadata::Builder::initGtOffsets() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp:: + FragmentMetadata::GenericTileOffsets>:: + init( + _builder.getPointerField(::capnp::bounded<21>() * ::capnp::POINTERS)); } inline void FragmentMetadata::Builder::adoptGtOffsets( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets>::adopt(_builder.getPointerField( - ::capnp::bounded<21>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets> FragmentMetadata::Builder::disownGtOffsets() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets>::disown(_builder.getPointerField( - ::capnp::bounded<21>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::FragmentMetadata:: + GenericTileOffsets>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp:: + FragmentMetadata::GenericTileOffsets>:: + adopt( + _builder.getPointerField(::capnp::bounded<21>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan< + ::tiledb::sm::serialization::capnp::FragmentMetadata::GenericTileOffsets> +FragmentMetadata::Builder::disownGtOffsets() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp:: + FragmentMetadata::GenericTileOffsets>:: + disown( + _builder.getPointerField(::capnp::bounded<21>() * ::capnp::POINTERS)); } inline bool FragmentMetadata::Reader::hasArraySchemaName() const { - return !_reader.getPointerField( - ::capnp::bounded<22>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<22>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::Builder::hasArraySchemaName() { - return !_builder.getPointerField( - ::capnp::bounded<22>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::Text::Reader FragmentMetadata::Reader::getArraySchemaName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<22>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder FragmentMetadata::Builder::getArraySchemaName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<22>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::Builder::setArraySchemaName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<22>() * ::capnp::POINTERS), value); -} -inline ::capnp::Text::Builder FragmentMetadata::Builder::initArraySchemaName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<22>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<22>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::Text::Reader FragmentMetadata::Reader::getArraySchemaName() + const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<22>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder FragmentMetadata::Builder::getArraySchemaName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<22>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::Builder::setArraySchemaName( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<22>() * ::capnp::POINTERS), + value); +} +inline ::capnp::Text::Builder FragmentMetadata::Builder::initArraySchemaName( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<22>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::Builder::adoptArraySchemaName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<22>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<22>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> FragmentMetadata::Builder::disownArraySchemaName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<22>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +FragmentMetadata::Builder::disownArraySchemaName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<22>() * ::capnp::POINTERS)); } -inline ::uint64_t FragmentMetadata::GenericTileOffsets::Reader::getRtree() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t FragmentMetadata::GenericTileOffsets::Reader::getRtree() + const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t FragmentMetadata::GenericTileOffsets::Builder::getRtree() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t FragmentMetadata::GenericTileOffsets::Builder::getRtree() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void FragmentMetadata::GenericTileOffsets::Builder::setRtree( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void FragmentMetadata::GenericTileOffsets::Builder::setRtree( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileOffsets() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); +inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileOffsets() + const { + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::GenericTileOffsets::Builder::hasTileOffsets() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::GenericTileOffsets::Reader::getTileOffsets() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::getTileOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileOffsets(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::initTileOffsets(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +FragmentMetadata::GenericTileOffsets::Reader::getTileOffsets() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::GenericTileOffsets::Builder::getTileOffsets() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileOffsets( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileOffsets( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::GenericTileOffsets::Builder::initTileOffsets( + unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::GenericTileOffsets::Builder::adoptTileOffsets( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::GenericTileOffsets::Builder::disownTileOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} - -inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileVarOffsets() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +FragmentMetadata::GenericTileOffsets::Builder::disownTileOffsets() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileVarOffsets() + const { + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::GenericTileOffsets::Builder::hasTileVarOffsets() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::GenericTileOffsets::Reader::getTileVarOffsets() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::getTileVarOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileVarOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileVarOffsets(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::initTileVarOffsets(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +FragmentMetadata::GenericTileOffsets::Reader::getTileVarOffsets() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::GenericTileOffsets::Builder::getTileVarOffsets() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileVarOffsets( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileVarOffsets( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::GenericTileOffsets::Builder::initTileVarOffsets( + unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::GenericTileOffsets::Builder::adoptTileVarOffsets( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::GenericTileOffsets::Builder::disownTileVarOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} - -inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileVarSizes() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +FragmentMetadata::GenericTileOffsets::Builder::disownTileVarOffsets() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} + +inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileVarSizes() + const { + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::GenericTileOffsets::Builder::hasTileVarSizes() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::GenericTileOffsets::Reader::getTileVarSizes() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::getTileVarSizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileVarSizes( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileVarSizes(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::initTileVarSizes(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +FragmentMetadata::GenericTileOffsets::Reader::getTileVarSizes() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::GenericTileOffsets::Builder::getTileVarSizes() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileVarSizes( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileVarSizes( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::GenericTileOffsets::Builder::initTileVarSizes( + unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::GenericTileOffsets::Builder::adoptTileVarSizes( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::GenericTileOffsets::Builder::disownTileVarSizes() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} - -inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileValidityOffsets() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); -} -inline bool FragmentMetadata::GenericTileOffsets::Builder::hasTileValidityOffsets() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::GenericTileOffsets::Reader::getTileValidityOffsets() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::getTileValidityOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileValidityOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileValidityOffsets(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::initTileValidityOffsets(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), size); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::adoptTileValidityOffsets( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::GenericTileOffsets::Builder::disownTileValidityOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} - -inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileMinOffsets() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +FragmentMetadata::GenericTileOffsets::Builder::disownTileVarSizes() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); +} + +inline bool +FragmentMetadata::GenericTileOffsets::Reader::hasTileValidityOffsets() const { + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); +} +inline bool +FragmentMetadata::GenericTileOffsets::Builder::hasTileValidityOffsets() { + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +FragmentMetadata::GenericTileOffsets::Reader::getTileValidityOffsets() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::GenericTileOffsets::Builder::getTileValidityOffsets() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void +FragmentMetadata::GenericTileOffsets::Builder::setTileValidityOffsets( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline void +FragmentMetadata::GenericTileOffsets::Builder::setTileValidityOffsets( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::GenericTileOffsets::Builder::initTileValidityOffsets( + unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + size); +} +inline void +FragmentMetadata::GenericTileOffsets::Builder::adoptTileValidityOffsets( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +FragmentMetadata::GenericTileOffsets::Builder::disownTileValidityOffsets() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} + +inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileMinOffsets() + const { + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::GenericTileOffsets::Builder::hasTileMinOffsets() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::GenericTileOffsets::Reader::getTileMinOffsets() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::getTileMinOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileMinOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileMinOffsets(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::initTileMinOffsets(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +FragmentMetadata::GenericTileOffsets::Reader::getTileMinOffsets() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::GenericTileOffsets::Builder::getTileMinOffsets() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileMinOffsets( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileMinOffsets( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::GenericTileOffsets::Builder::initTileMinOffsets( + unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::GenericTileOffsets::Builder::adoptTileMinOffsets( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::GenericTileOffsets::Builder::disownTileMinOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); -} - -inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileMaxOffsets() const { - return !_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +FragmentMetadata::GenericTileOffsets::Builder::disownTileMinOffsets() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +} + +inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileMaxOffsets() + const { + return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::GenericTileOffsets::Builder::hasTileMaxOffsets() { - return !_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::GenericTileOffsets::Reader::getTileMaxOffsets() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::getTileMaxOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileMaxOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileMaxOffsets(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::initTileMaxOffsets(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +FragmentMetadata::GenericTileOffsets::Reader::getTileMaxOffsets() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::GenericTileOffsets::Builder::getTileMaxOffsets() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileMaxOffsets( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileMaxOffsets( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::GenericTileOffsets::Builder::initTileMaxOffsets( + unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::GenericTileOffsets::Builder::adoptTileMaxOffsets( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::GenericTileOffsets::Builder::disownTileMaxOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<5>() * ::capnp::POINTERS)); -} - -inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileSumOffsets() const { - return !_reader.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +FragmentMetadata::GenericTileOffsets::Builder::disownTileMaxOffsets() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); +} + +inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileSumOffsets() + const { + return !_reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) + .isNull(); } inline bool FragmentMetadata::GenericTileOffsets::Builder::hasTileSumOffsets() { - return !_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::GenericTileOffsets::Reader::getTileSumOffsets() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::getTileSumOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileSumOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileSumOffsets(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::initTileSumOffsets(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +FragmentMetadata::GenericTileOffsets::Reader::getTileSumOffsets() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::GenericTileOffsets::Builder::getTileSumOffsets() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileSumOffsets( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + value); +} +inline void FragmentMetadata::GenericTileOffsets::Builder::setTileSumOffsets( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::GenericTileOffsets::Builder::initTileSumOffsets( + unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + size); } inline void FragmentMetadata::GenericTileOffsets::Builder::adoptTileSumOffsets( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::GenericTileOffsets::Builder::disownTileSumOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<6>() * ::capnp::POINTERS)); -} - -inline bool FragmentMetadata::GenericTileOffsets::Reader::hasTileNullCountOffsets() const { - return !_reader.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); -} -inline bool FragmentMetadata::GenericTileOffsets::Builder::hasTileNullCountOffsets() { - return !_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader FragmentMetadata::GenericTileOffsets::Reader::getTileNullCountOffsets() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::getTileNullCountOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileNullCountOffsets( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), value); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::setTileNullCountOffsets(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder FragmentMetadata::GenericTileOffsets::Builder::initTileNullCountOffsets(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), size); -} -inline void FragmentMetadata::GenericTileOffsets::Builder::adoptTileNullCountOffsets( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> FragmentMetadata::GenericTileOffsets::Builder::disownTileNullCountOffsets() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<7>() * ::capnp::POINTERS)); -} - -inline ::uint64_t FragmentMetadata::GenericTileOffsets::Reader::getFragmentMinMaxSumNullCountOffset() const { - return _reader.getDataField< ::uint64_t>( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +FragmentMetadata::GenericTileOffsets::Builder::disownTileSumOffsets() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS)); +} + +inline bool +FragmentMetadata::GenericTileOffsets::Reader::hasTileNullCountOffsets() const { + return !_reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) + .isNull(); +} +inline bool +FragmentMetadata::GenericTileOffsets::Builder::hasTileNullCountOffsets() { + return !_builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +FragmentMetadata::GenericTileOffsets::Reader::getTileNullCountOffsets() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::GenericTileOffsets::Builder::getTileNullCountOffsets() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); +} +inline void +FragmentMetadata::GenericTileOffsets::Builder::setTileNullCountOffsets( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + value); +} +inline void +FragmentMetadata::GenericTileOffsets::Builder::setTileNullCountOffsets( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +FragmentMetadata::GenericTileOffsets::Builder::initTileNullCountOffsets( + unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + size); +} +inline void +FragmentMetadata::GenericTileOffsets::Builder::adoptTileNullCountOffsets( + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +FragmentMetadata::GenericTileOffsets::Builder::disownTileNullCountOffsets() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<7>() * ::capnp::POINTERS)); +} + +inline ::uint64_t FragmentMetadata::GenericTileOffsets::Reader:: + getFragmentMinMaxSumNullCountOffset() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t FragmentMetadata::GenericTileOffsets::Builder::getFragmentMinMaxSumNullCountOffset() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t FragmentMetadata::GenericTileOffsets::Builder:: + getFragmentMinMaxSumNullCountOffset() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void FragmentMetadata::GenericTileOffsets::Builder::setFragmentMinMaxSumNullCountOffset( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void FragmentMetadata::GenericTileOffsets::Builder:: + setFragmentMinMaxSumNullCountOffset(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t FragmentMetadata::GenericTileOffsets::Reader::getProcessedConditionsOffsets() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t +FragmentMetadata::GenericTileOffsets::Reader::getProcessedConditionsOffsets() + const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint64_t FragmentMetadata::GenericTileOffsets::Builder::getProcessedConditionsOffsets() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t +FragmentMetadata::GenericTileOffsets::Builder::getProcessedConditionsOffsets() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline void FragmentMetadata::GenericTileOffsets::Builder::setProcessedConditionsOffsets( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void +FragmentMetadata::GenericTileOffsets::Builder::setProcessedConditionsOffsets( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t MultiPartUploadState::Reader::getPartNumber() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t MultiPartUploadState::Reader::getPartNumber() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t MultiPartUploadState::Builder::getPartNumber() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t MultiPartUploadState::Builder::getPartNumber() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void MultiPartUploadState::Builder::setPartNumber( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void MultiPartUploadState::Builder::setPartNumber(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool MultiPartUploadState::Reader::hasUploadId() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool MultiPartUploadState::Builder::hasUploadId() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader MultiPartUploadState::Reader::getUploadId() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader MultiPartUploadState::Reader::getUploadId() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder MultiPartUploadState::Builder::getUploadId() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder MultiPartUploadState::Builder::getUploadId() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void MultiPartUploadState::Builder::setUploadId( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void MultiPartUploadState::Builder::setUploadId( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder MultiPartUploadState::Builder::initUploadId(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder MultiPartUploadState::Builder::initUploadId( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void MultiPartUploadState::Builder::adoptUploadId( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> MultiPartUploadState::Builder::disownUploadId() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +MultiPartUploadState::Builder::disownUploadId() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool MultiPartUploadState::Reader::hasStatus() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool MultiPartUploadState::Builder::hasStatus() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader MultiPartUploadState::Reader::getStatus() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader MultiPartUploadState::Reader::getStatus() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder MultiPartUploadState::Builder::getStatus() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder MultiPartUploadState::Builder::getStatus() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void MultiPartUploadState::Builder::setStatus( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void MultiPartUploadState::Builder::setStatus( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder MultiPartUploadState::Builder::initStatus(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder MultiPartUploadState::Builder::initStatus( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void MultiPartUploadState::Builder::adoptStatus( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> MultiPartUploadState::Builder::disownStatus() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +MultiPartUploadState::Builder::disownStatus() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool MultiPartUploadState::Reader::hasCompletedParts() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool MultiPartUploadState::Builder::hasCompletedParts() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>::Reader MultiPartUploadState::Reader::getCompletedParts() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>::Builder MultiPartUploadState::Builder::getCompletedParts() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline void MultiPartUploadState::Builder::setCompletedParts( ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>::Builder MultiPartUploadState::Builder::initCompletedParts(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>::Reader +MultiPartUploadState::Reader::getCompletedParts() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<2>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>::Builder +MultiPartUploadState::Builder::getCompletedParts() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<2>() * + ::capnp::POINTERS)); +} +inline void MultiPartUploadState::Builder::setCompletedParts( + ::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>::Builder +MultiPartUploadState::Builder::initCompletedParts(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void MultiPartUploadState::Builder::adoptCompletedParts( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>> MultiPartUploadState::Builder::disownCompletedParts() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::CompletedPart, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>> +MultiPartUploadState::Builder::disownCompletedParts() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::CompletedPart, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<2>() * + ::capnp::POINTERS)); } inline bool MultiPartUploadState::Reader::hasBufferedChunks() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool MultiPartUploadState::Builder::hasBufferedChunks() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>::Reader MultiPartUploadState::Reader::getBufferedChunks() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>::Builder MultiPartUploadState::Builder::getBufferedChunks() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline void MultiPartUploadState::Builder::setBufferedChunks( ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>::Builder MultiPartUploadState::Builder::initBufferedChunks(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>::Reader +MultiPartUploadState::Reader::getBufferedChunks() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<3>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>::Builder +MultiPartUploadState::Builder::getBufferedChunks() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<3>() * + ::capnp::POINTERS)); +} +inline void MultiPartUploadState::Builder::setBufferedChunks( + ::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>::Builder +MultiPartUploadState::Builder::initBufferedChunks(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + size); } inline void MultiPartUploadState::Builder::adoptBufferedChunks( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>> MultiPartUploadState::Builder::disownBufferedChunks() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::BufferedChunk, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>> +MultiPartUploadState::Builder::disownBufferedChunks() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::BufferedChunk, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<3>() * + ::capnp::POINTERS)); } inline bool CompletedPart::Reader::hasETag() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool CompletedPart::Builder::hasETag() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader CompletedPart::Reader::getETag() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader CompletedPart::Reader::getETag() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder CompletedPart::Builder::getETag() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder CompletedPart::Builder::getETag() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void CompletedPart::Builder::setETag( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void CompletedPart::Builder::setETag(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder CompletedPart::Builder::initETag(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder CompletedPart::Builder::initETag( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void CompletedPart::Builder::adoptETag( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> CompletedPart::Builder::disownETag() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> CompletedPart::Builder::disownETag() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t CompletedPart::Reader::getPartNumber() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t CompletedPart::Reader::getPartNumber() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t CompletedPart::Builder::getPartNumber() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t CompletedPart::Builder::getPartNumber() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void CompletedPart::Builder::setPartNumber( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void CompletedPart::Builder::setPartNumber(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool WrittenFragmentInfo::Reader::hasUri() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool WrittenFragmentInfo::Builder::hasUri() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader WrittenFragmentInfo::Reader::getUri() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader WrittenFragmentInfo::Reader::getUri() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder WrittenFragmentInfo::Builder::getUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder WrittenFragmentInfo::Builder::getUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void WrittenFragmentInfo::Builder::setUri( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void WrittenFragmentInfo::Builder::setUri(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder WrittenFragmentInfo::Builder::initUri(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder WrittenFragmentInfo::Builder::initUri( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void WrittenFragmentInfo::Builder::adoptUri( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> WrittenFragmentInfo::Builder::disownUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +WrittenFragmentInfo::Builder::disownUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool WrittenFragmentInfo::Reader::hasTimestampRange() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool WrittenFragmentInfo::Builder::hasTimestampRange() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader WrittenFragmentInfo::Reader::getTimestampRange() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder WrittenFragmentInfo::Builder::getTimestampRange() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void WrittenFragmentInfo::Builder::setTimestampRange( ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline void WrittenFragmentInfo::Builder::setTimestampRange(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder WrittenFragmentInfo::Builder::initTimestampRange(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader +WrittenFragmentInfo::Reader::getTimestampRange() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +WrittenFragmentInfo::Builder::getTimestampRange() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void WrittenFragmentInfo::Builder::setTimestampRange( + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline void WrittenFragmentInfo::Builder::setTimestampRange( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>::Builder +WrittenFragmentInfo::Builder::initTimestampRange(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void WrittenFragmentInfo::Builder::adoptTimestampRange( - ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>> WrittenFragmentInfo::Builder::disownTimestampRange() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t, ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>&& + value) { + ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>> +WrittenFragmentInfo::Builder::disownTimestampRange() { + return ::capnp::_::PointerHelpers< + ::capnp::List<::uint64_t, ::capnp::Kind::PRIMITIVE>>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool BufferedChunk::Reader::hasUri() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool BufferedChunk::Builder::hasUri() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader BufferedChunk::Reader::getUri() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader BufferedChunk::Reader::getUri() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder BufferedChunk::Builder::getUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder BufferedChunk::Builder::getUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void BufferedChunk::Builder::setUri( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void BufferedChunk::Builder::setUri(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder BufferedChunk::Builder::initUri(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder BufferedChunk::Builder::initUri( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void BufferedChunk::Builder::adoptUri( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> BufferedChunk::Builder::disownUri() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> BufferedChunk::Builder::disownUri() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t BufferedChunk::Reader::getSize() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t BufferedChunk::Reader::getSize() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t BufferedChunk::Builder::getSize() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t BufferedChunk::Builder::getSize() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void BufferedChunk::Builder::setSize( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void BufferedChunk::Builder::setSize(::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool ArrayDeleteFragmentsListRequest::Reader::hasConfig() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayDeleteFragmentsListRequest::Builder::hasConfig() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader ArrayDeleteFragmentsListRequest::Reader::getConfig() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader +ArrayDeleteFragmentsListRequest::Reader::getConfig() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayDeleteFragmentsListRequest::Builder::getConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +ArrayDeleteFragmentsListRequest::Builder::getConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline ArrayDeleteFragmentsListRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline +ArrayDeleteFragmentsListRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void ArrayDeleteFragmentsListRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void ArrayDeleteFragmentsListRequest::Builder::setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayDeleteFragmentsListRequest::Builder::initConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +ArrayDeleteFragmentsListRequest::Builder::initConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void ArrayDeleteFragmentsListRequest::Builder::adoptConfig( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> ArrayDeleteFragmentsListRequest::Builder::disownConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> +ArrayDeleteFragmentsListRequest::Builder::disownConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ArrayDeleteFragmentsListRequest::Reader::hasEntries() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayDeleteFragmentsListRequest::Builder::hasEntries() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayDeleteFragmentsListRequest::Reader::getEntries() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDeleteFragmentsListRequest::Builder::getEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void ArrayDeleteFragmentsListRequest::Builder::setEntries( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline void ArrayDeleteFragmentsListRequest::Builder::setEntries(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayDeleteFragmentsListRequest::Builder::initEntries(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +ArrayDeleteFragmentsListRequest::Reader::getEntries() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDeleteFragmentsListRequest::Builder::getEntries() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void ArrayDeleteFragmentsListRequest::Builder::setEntries( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline void ArrayDeleteFragmentsListRequest::Builder::setEntries( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayDeleteFragmentsListRequest::Builder::initEntries(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void ArrayDeleteFragmentsListRequest::Builder::adoptEntries( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayDeleteFragmentsListRequest::Builder::disownEntries() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +ArrayDeleteFragmentsListRequest::Builder::disownEntries() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool ArrayDeleteFragmentsTimestampsRequest::Reader::hasConfig() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayDeleteFragmentsTimestampsRequest::Builder::hasConfig() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader ArrayDeleteFragmentsTimestampsRequest::Reader::getConfig() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader +ArrayDeleteFragmentsTimestampsRequest::Reader::getConfig() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayDeleteFragmentsTimestampsRequest::Builder::getConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +ArrayDeleteFragmentsTimestampsRequest::Builder::getConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline ArrayDeleteFragmentsTimestampsRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline +ArrayDeleteFragmentsTimestampsRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void ArrayDeleteFragmentsTimestampsRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void ArrayDeleteFragmentsTimestampsRequest::Builder::setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayDeleteFragmentsTimestampsRequest::Builder::initConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +ArrayDeleteFragmentsTimestampsRequest::Builder::initConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void ArrayDeleteFragmentsTimestampsRequest::Builder::adoptConfig( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> ArrayDeleteFragmentsTimestampsRequest::Builder::disownConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> +ArrayDeleteFragmentsTimestampsRequest::Builder::disownConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t ArrayDeleteFragmentsTimestampsRequest::Reader::getStartTimestamp() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t +ArrayDeleteFragmentsTimestampsRequest::Reader::getStartTimestamp() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t ArrayDeleteFragmentsTimestampsRequest::Builder::getStartTimestamp() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t +ArrayDeleteFragmentsTimestampsRequest::Builder::getStartTimestamp() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ArrayDeleteFragmentsTimestampsRequest::Builder::setStartTimestamp( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void ArrayDeleteFragmentsTimestampsRequest::Builder::setStartTimestamp( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t ArrayDeleteFragmentsTimestampsRequest::Reader::getEndTimestamp() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t +ArrayDeleteFragmentsTimestampsRequest::Reader::getEndTimestamp() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline ::uint64_t ArrayDeleteFragmentsTimestampsRequest::Builder::getEndTimestamp() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t +ArrayDeleteFragmentsTimestampsRequest::Builder::getEndTimestamp() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS); } -inline void ArrayDeleteFragmentsTimestampsRequest::Builder::setEndTimestamp( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void ArrayDeleteFragmentsTimestampsRequest::Builder::setEndTimestamp( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); } inline bool ArrayConsolidationRequest::Reader::hasConfig() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayConsolidationRequest::Builder::hasConfig() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader ArrayConsolidationRequest::Reader::getConfig() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader +ArrayConsolidationRequest::Reader::getConfig() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayConsolidationRequest::Builder::getConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +ArrayConsolidationRequest::Builder::getConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline ArrayConsolidationRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline +ArrayConsolidationRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void ArrayConsolidationRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void ArrayConsolidationRequest::Builder::setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayConsolidationRequest::Builder::initConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +ArrayConsolidationRequest::Builder::initConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void ArrayConsolidationRequest::Builder::adoptConfig( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> ArrayConsolidationRequest::Builder::disownConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> +ArrayConsolidationRequest::Builder::disownConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool ArrayConsolidationRequest::Reader::hasFragments() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayConsolidationRequest::Builder::hasFragments() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader ArrayConsolidationRequest::Reader::getFragments() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayConsolidationRequest::Builder::getFragments() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void ArrayConsolidationRequest::Builder::setFragments( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline void ArrayConsolidationRequest::Builder::setFragments(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder ArrayConsolidationRequest::Builder::initFragments(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +ArrayConsolidationRequest::Reader::getFragments() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayConsolidationRequest::Builder::getFragments() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void ArrayConsolidationRequest::Builder::setFragments( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline void ArrayConsolidationRequest::Builder::setFragments( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +ArrayConsolidationRequest::Builder::initFragments(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void ArrayConsolidationRequest::Builder::adoptFragments( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> ArrayConsolidationRequest::Builder::disownFragments() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +ArrayConsolidationRequest::Builder::disownFragments() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool ArrayVacuumRequest::Reader::hasConfig() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ArrayVacuumRequest::Builder::hasConfig() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader ArrayVacuumRequest::Reader::getConfig() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader +ArrayVacuumRequest::Reader::getConfig() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayVacuumRequest::Builder::getConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +ArrayVacuumRequest::Builder::getConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline ArrayVacuumRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline +ArrayVacuumRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void ArrayVacuumRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void ArrayVacuumRequest::Builder::setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder ArrayVacuumRequest::Builder::initConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +ArrayVacuumRequest::Builder::initConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void ArrayVacuumRequest::Builder::adoptConfig( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> ArrayVacuumRequest::Builder::disownConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> +ArrayVacuumRequest::Builder::disownConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool LoadEnumerationsRequest::Reader::hasConfig() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool LoadEnumerationsRequest::Builder::hasConfig() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader LoadEnumerationsRequest::Reader::getConfig() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader +LoadEnumerationsRequest::Reader::getConfig() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder LoadEnumerationsRequest::Builder::getConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +LoadEnumerationsRequest::Builder::getConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline LoadEnumerationsRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline +LoadEnumerationsRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void LoadEnumerationsRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void LoadEnumerationsRequest::Builder::setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder LoadEnumerationsRequest::Builder::initConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +LoadEnumerationsRequest::Builder::initConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void LoadEnumerationsRequest::Builder::adoptConfig( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> LoadEnumerationsRequest::Builder::disownConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> +LoadEnumerationsRequest::Builder::disownConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool LoadEnumerationsRequest::Reader::hasEnumerations() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool LoadEnumerationsRequest::Builder::hasEnumerations() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader LoadEnumerationsRequest::Reader::getEnumerations() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder LoadEnumerationsRequest::Builder::getEnumerations() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void LoadEnumerationsRequest::Builder::setEnumerations( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline void LoadEnumerationsRequest::Builder::setEnumerations(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder LoadEnumerationsRequest::Builder::initEnumerations(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +LoadEnumerationsRequest::Reader::getEnumerations() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +LoadEnumerationsRequest::Builder::getEnumerations() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void LoadEnumerationsRequest::Builder::setEnumerations( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline void LoadEnumerationsRequest::Builder::setEnumerations( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +LoadEnumerationsRequest::Builder::initEnumerations(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void LoadEnumerationsRequest::Builder::adoptEnumerations( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> LoadEnumerationsRequest::Builder::disownEnumerations() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +LoadEnumerationsRequest::Builder::disownEnumerations() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool LoadEnumerationsResponse::Reader::hasEnumerations() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool LoadEnumerationsResponse::Builder::hasEnumerations() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader LoadEnumerationsResponse::Reader::getEnumerations() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder LoadEnumerationsResponse::Builder::getEnumerations() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void LoadEnumerationsResponse::Builder::setEnumerations( ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>::Builder LoadEnumerationsResponse::Builder::initEnumerations(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader +LoadEnumerationsResponse::Reader::getEnumerations() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder +LoadEnumerationsResponse::Builder::getEnumerations() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void LoadEnumerationsResponse::Builder::setEnumerations( + ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>::Builder +LoadEnumerationsResponse::Builder::initEnumerations(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void LoadEnumerationsResponse::Builder::adoptEnumerations( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>> LoadEnumerationsResponse::Builder::disownEnumerations() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Enumeration, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>> +LoadEnumerationsResponse::Builder::disownEnumerations() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Enumeration, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } inline bool LoadEnumerationsResponse::Reader::hasAllEnumerations() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool LoadEnumerationsResponse::Builder::hasAllEnumerations() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::MapEnumeration::Reader LoadEnumerationsResponse::Reader::getAllEnumerations() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapEnumeration>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapEnumeration::Reader +LoadEnumerationsResponse::Reader::getAllEnumerations() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::MapEnumeration>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::MapEnumeration::Builder LoadEnumerationsResponse::Builder::getAllEnumerations() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapEnumeration>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapEnumeration::Builder +LoadEnumerationsResponse::Builder::getAllEnumerations() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::MapEnumeration>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::MapEnumeration::Pipeline LoadEnumerationsResponse::Pipeline::getAllEnumerations() { - return ::tiledb::sm::serialization::capnp::MapEnumeration::Pipeline(_typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::MapEnumeration::Pipeline +LoadEnumerationsResponse::Pipeline::getAllEnumerations() { + return ::tiledb::sm::serialization::capnp::MapEnumeration::Pipeline( + _typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void LoadEnumerationsResponse::Builder::setAllEnumerations( ::tiledb::sm::serialization::capnp::MapEnumeration::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapEnumeration>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void LoadEnumerationsResponse::Builder::setAllEnumerations( + ::tiledb::sm::serialization::capnp::MapEnumeration::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::MapEnumeration>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::MapEnumeration::Builder LoadEnumerationsResponse::Builder::initAllEnumerations() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapEnumeration>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::MapEnumeration::Builder +LoadEnumerationsResponse::Builder::initAllEnumerations() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::MapEnumeration>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void LoadEnumerationsResponse::Builder::adoptAllEnumerations( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapEnumeration>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapEnumeration>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapEnumeration>&& + value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::MapEnumeration>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::MapEnumeration> LoadEnumerationsResponse::Builder::disownAllEnumerations() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::MapEnumeration>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::MapEnumeration> +LoadEnumerationsResponse::Builder::disownAllEnumerations() { + return ::capnp::_::PointerHelpers< + ::tiledb::sm::serialization::capnp::MapEnumeration>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool LoadArraySchemaRequest::Reader::hasConfig() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool LoadArraySchemaRequest::Builder::hasConfig() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader LoadArraySchemaRequest::Reader::getConfig() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader +LoadArraySchemaRequest::Reader::getConfig() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder LoadArraySchemaRequest::Builder::getConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +LoadArraySchemaRequest::Builder::getConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline LoadArraySchemaRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline +LoadArraySchemaRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void LoadArraySchemaRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void LoadArraySchemaRequest::Builder::setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder LoadArraySchemaRequest::Builder::initConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +LoadArraySchemaRequest::Builder::initConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void LoadArraySchemaRequest::Builder::adoptConfig( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> LoadArraySchemaRequest::Builder::disownConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> +LoadArraySchemaRequest::Builder::disownConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool LoadArraySchemaRequest::Reader::getIncludeEnumerations() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool LoadArraySchemaRequest::Builder::getIncludeEnumerations() { - return _builder.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void LoadArraySchemaRequest::Builder::setIncludeEnumerations(bool value) { - _builder.setDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +inline void LoadArraySchemaRequest::Builder::setIncludeEnumerations( + bool value) { + _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool LoadArraySchemaResponse::Reader::hasSchema() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool LoadArraySchemaResponse::Builder::hasSchema() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader LoadArraySchemaResponse::Reader::getSchema() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Reader +LoadArraySchemaResponse::Reader::getSchema() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder LoadArraySchemaResponse::Builder::getSchema() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder +LoadArraySchemaResponse::Builder::getSchema() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline LoadArraySchemaResponse::Pipeline::getSchema() { - return ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline +LoadArraySchemaResponse::Pipeline::getSchema() { + return ::tiledb::sm::serialization::capnp::ArraySchema::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void LoadArraySchemaResponse::Builder::setSchema( ::tiledb::sm::serialization::capnp::ArraySchema::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void LoadArraySchemaResponse::Builder::setSchema( + ::tiledb::sm::serialization::capnp::ArraySchema::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder LoadArraySchemaResponse::Builder::initSchema() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::ArraySchema::Builder +LoadArraySchemaResponse::Builder::initSchema() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void LoadArraySchemaResponse::Builder::adoptSchema( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::ArraySchema> LoadArraySchemaResponse::Builder::disownSchema() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::ArraySchema>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::ArraySchema> +LoadArraySchemaResponse::Builder::disownSchema() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::ArraySchema>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool LoadArraySchemaResponse::Reader::hasArraySchemasAll() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool LoadArraySchemaResponse::Builder::hasArraySchemasAll() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader LoadArraySchemaResponse::Reader::getArraySchemasAll() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder LoadArraySchemaResponse::Builder::getArraySchemasAll() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline LoadArraySchemaResponse::Pipeline::getArraySchemasAll() { - return ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline(_typeless.getPointerField(1)); -} -#endif // !CAPNP_LITE -inline void LoadArraySchemaResponse::Builder::setArraySchemasAll( ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder LoadArraySchemaResponse::Builder::initArraySchemasAll() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::tiledb::sm::serialization::capnp:: + Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Reader + LoadArraySchemaResponse::Reader::getArraySchemasAll() const { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + get(_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp:: + Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder + LoadArraySchemaResponse::Builder::getArraySchemasAll() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + get(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Pipeline +LoadArraySchemaResponse::Pipeline::getArraySchemasAll() { + return ::tiledb::sm::serialization::capnp:: + Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>:: + Pipeline(_typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void LoadArraySchemaResponse::Builder::setArraySchemasAll( + ::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::tiledb::sm::serialization::capnp:: + Map<::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>::Builder + LoadArraySchemaResponse::Builder::initArraySchemasAll() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void LoadArraySchemaResponse::Builder::adoptArraySchemasAll( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>> LoadArraySchemaResponse::Builder::disownArraySchemasAll() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Map< ::capnp::Text, ::tiledb::sm::serialization::capnp::ArraySchema>>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>> +LoadArraySchemaResponse::Builder::disownArraySchemasAll() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Map< + ::capnp::Text, + ::tiledb::sm::serialization::capnp::ArraySchema>>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool QueryPlanRequest::Reader::hasConfig() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool QueryPlanRequest::Builder::hasConfig() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader QueryPlanRequest::Reader::getConfig() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader +QueryPlanRequest::Reader::getConfig() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder QueryPlanRequest::Builder::getConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +QueryPlanRequest::Builder::getConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline QueryPlanRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline +QueryPlanRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void QueryPlanRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void QueryPlanRequest::Builder::setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder QueryPlanRequest::Builder::initConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +QueryPlanRequest::Builder::initConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void QueryPlanRequest::Builder::adoptConfig( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> QueryPlanRequest::Builder::disownConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> +QueryPlanRequest::Builder::disownConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool QueryPlanRequest::Reader::hasQuery() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool QueryPlanRequest::Builder::hasQuery() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Query::Reader QueryPlanRequest::Reader::getQuery() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Query>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Query::Reader +QueryPlanRequest::Reader::getQuery() const { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Query>:: + get(_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Query::Builder QueryPlanRequest::Builder::getQuery() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Query>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Query::Builder +QueryPlanRequest::Builder::getQuery() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Query>:: + get(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Query::Pipeline QueryPlanRequest::Pipeline::getQuery() { - return ::tiledb::sm::serialization::capnp::Query::Pipeline(_typeless.getPointerField(1)); +inline ::tiledb::sm::serialization::capnp::Query::Pipeline +QueryPlanRequest::Pipeline::getQuery() { + return ::tiledb::sm::serialization::capnp::Query::Pipeline( + _typeless.getPointerField(1)); } #endif // !CAPNP_LITE -inline void QueryPlanRequest::Builder::setQuery( ::tiledb::sm::serialization::capnp::Query::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Query>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void QueryPlanRequest::Builder::setQuery( + ::tiledb::sm::serialization::capnp::Query::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Query>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Query::Builder QueryPlanRequest::Builder::initQuery() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Query>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Query::Builder +QueryPlanRequest::Builder::initQuery() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Query>:: + init(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void QueryPlanRequest::Builder::adoptQuery( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Query>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Query>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Query>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Query>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Query> QueryPlanRequest::Builder::disownQuery() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Query>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Query> +QueryPlanRequest::Builder::disownQuery() { + return ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Query>:: + disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool QueryPlanResponse::Reader::hasQueryLayout() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool QueryPlanResponse::Builder::hasQueryLayout() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader QueryPlanResponse::Reader::getQueryLayout() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader QueryPlanResponse::Reader::getQueryLayout() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder QueryPlanResponse::Builder::getQueryLayout() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder QueryPlanResponse::Builder::getQueryLayout() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void QueryPlanResponse::Builder::setQueryLayout( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void QueryPlanResponse::Builder::setQueryLayout( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder QueryPlanResponse::Builder::initQueryLayout(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder QueryPlanResponse::Builder::initQueryLayout( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void QueryPlanResponse::Builder::adoptQueryLayout( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> QueryPlanResponse::Builder::disownQueryLayout() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +QueryPlanResponse::Builder::disownQueryLayout() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool QueryPlanResponse::Reader::hasStrategyName() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool QueryPlanResponse::Builder::hasStrategyName() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::Text::Reader QueryPlanResponse::Reader::getStrategyName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::Text::Builder QueryPlanResponse::Builder::getStrategyName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void QueryPlanResponse::Builder::setStrategyName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::capnp::Text::Builder QueryPlanResponse::Builder::initStrategyName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::Text::Reader QueryPlanResponse::Reader::getStrategyName() + const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder QueryPlanResponse::Builder::getStrategyName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void QueryPlanResponse::Builder::setStrategyName( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::capnp::Text::Builder QueryPlanResponse::Builder::initStrategyName( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void QueryPlanResponse::Builder::adoptStrategyName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> QueryPlanResponse::Builder::disownStrategyName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +QueryPlanResponse::Builder::disownStrategyName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool QueryPlanResponse::Reader::hasArrayType() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool QueryPlanResponse::Builder::hasArrayType() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader QueryPlanResponse::Reader::getArrayType() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader QueryPlanResponse::Reader::getArrayType() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder QueryPlanResponse::Builder::getArrayType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder QueryPlanResponse::Builder::getArrayType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void QueryPlanResponse::Builder::setArrayType( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void QueryPlanResponse::Builder::setArrayType( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder QueryPlanResponse::Builder::initArrayType(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder QueryPlanResponse::Builder::initArrayType( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void QueryPlanResponse::Builder::adoptArrayType( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> QueryPlanResponse::Builder::disownArrayType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +QueryPlanResponse::Builder::disownArrayType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } inline bool QueryPlanResponse::Reader::hasAttributeNames() const { - return !_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); } inline bool QueryPlanResponse::Builder::hasAttributeNames() { - return !_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader QueryPlanResponse::Reader::getAttributeNames() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder QueryPlanResponse::Builder::getAttributeNames() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); -} -inline void QueryPlanResponse::Builder::setAttributeNames( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline void QueryPlanResponse::Builder::setAttributeNames(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder QueryPlanResponse::Builder::initAttributeNames(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +QueryPlanResponse::Reader::getAttributeNames() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +QueryPlanResponse::Builder::getAttributeNames() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); +} +inline void QueryPlanResponse::Builder::setAttributeNames( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline void QueryPlanResponse::Builder::setAttributeNames( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +QueryPlanResponse::Builder::initAttributeNames(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + size); } inline void QueryPlanResponse::Builder::adoptAttributeNames( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> QueryPlanResponse::Builder::disownAttributeNames() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<3>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +QueryPlanResponse::Builder::disownAttributeNames() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS)); } inline bool QueryPlanResponse::Reader::hasDimensionNames() const { - return !_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); } inline bool QueryPlanResponse::Builder::hasDimensionNames() { - return !_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader QueryPlanResponse::Reader::getDimensionNames() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_reader.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder QueryPlanResponse::Builder::getDimensionNames() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::get(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); -} -inline void QueryPlanResponse::Builder::setDimensionNames( ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); -} -inline void QueryPlanResponse::Builder::setDimensionNames(::kj::ArrayPtr value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::set(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>::Builder QueryPlanResponse::Builder::initDimensionNames(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::init(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader +QueryPlanResponse::Reader::getDimensionNames() const { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _reader.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +QueryPlanResponse::Builder::getDimensionNames() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::get( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); +} +inline void QueryPlanResponse::Builder::setDimensionNames( + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); +} +inline void QueryPlanResponse::Builder::setDimensionNames( + ::kj::ArrayPtr value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::set( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Builder +QueryPlanResponse::Builder::initDimensionNames(unsigned int size) { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::init( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + size); } inline void QueryPlanResponse::Builder::adoptDimensionNames( - ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>&& + value) { + ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::adopt( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>> QueryPlanResponse::Builder::disownDimensionNames() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>>::disown(_builder.getPointerField( - ::capnp::bounded<4>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>> +QueryPlanResponse::Builder::disownDimensionNames() { + return ::capnp::_:: + PointerHelpers<::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>>::disown( + _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } inline bool ConsolidationPlanRequest::Reader::hasConfig() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ConsolidationPlanRequest::Builder::hasConfig() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::tiledb::sm::serialization::capnp::Config::Reader ConsolidationPlanRequest::Reader::getConfig() const { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Reader +ConsolidationPlanRequest::Reader::getConfig() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::Config::Builder ConsolidationPlanRequest::Builder::getConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +ConsolidationPlanRequest::Builder::getConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } #if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::Config::Pipeline ConsolidationPlanRequest::Pipeline::getConfig() { - return ::tiledb::sm::serialization::capnp::Config::Pipeline(_typeless.getPointerField(0)); +inline ::tiledb::sm::serialization::capnp::Config::Pipeline +ConsolidationPlanRequest::Pipeline::getConfig() { + return ::tiledb::sm::serialization::capnp::Config::Pipeline( + _typeless.getPointerField(0)); } #endif // !CAPNP_LITE -inline void ConsolidationPlanRequest::Builder::setConfig( ::tiledb::sm::serialization::capnp::Config::Reader value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void ConsolidationPlanRequest::Builder::setConfig( + ::tiledb::sm::serialization::capnp::Config::Reader value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::Config::Builder ConsolidationPlanRequest::Builder::initConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::tiledb::sm::serialization::capnp::Config::Builder +ConsolidationPlanRequest::Builder::initConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline void ConsolidationPlanRequest::Builder::adoptConfig( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config>&& value) { - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config>&& value) { + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::Config>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::Config> ConsolidationPlanRequest::Builder::disownConfig() { - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::Config>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Config> +ConsolidationPlanRequest::Builder::disownConfig() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::Config>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::uint64_t ConsolidationPlanRequest::Reader::getFragmentSize() const { - return _reader.getDataField< ::uint64_t>( +inline ::uint64_t ConsolidationPlanRequest::Reader::getFragmentSize() const { + return _reader.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint64_t ConsolidationPlanRequest::Builder::getFragmentSize() { - return _builder.getDataField< ::uint64_t>( +inline ::uint64_t ConsolidationPlanRequest::Builder::getFragmentSize() { + return _builder.getDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ConsolidationPlanRequest::Builder::setFragmentSize( ::uint64_t value) { - _builder.setDataField< ::uint64_t>( +inline void ConsolidationPlanRequest::Builder::setFragmentSize( + ::uint64_t value) { + _builder.setDataField<::uint64_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool ConsolidationPlanResponse::Reader::hasFragmentUrisPerNode() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool ConsolidationPlanResponse::Builder::hasFragmentUrisPerNode() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Reader ConsolidationPlanResponse::Reader::getFragmentUrisPerNode() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Builder ConsolidationPlanResponse::Builder::getFragmentUrisPerNode() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void ConsolidationPlanResponse::Builder::setFragmentUrisPerNode( ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline void ConsolidationPlanResponse::Builder::setFragmentUrisPerNode(::kj::ArrayPtr::Reader> value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>::Builder ConsolidationPlanResponse::Builder::initFragmentUrisPerNode(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>::Reader +ConsolidationPlanResponse::Reader::getFragmentUrisPerNode() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>::Builder +ConsolidationPlanResponse::Builder::getFragmentUrisPerNode() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void ConsolidationPlanResponse::Builder::setFragmentUrisPerNode( + ::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline void ConsolidationPlanResponse::Builder::setFragmentUrisPerNode( + ::kj::ArrayPtr< + const ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>::Reader> + value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>::Builder +ConsolidationPlanResponse::Builder::initFragmentUrisPerNode(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void ConsolidationPlanResponse::Builder::adoptFragmentUrisPerNode( - ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>> ConsolidationPlanResponse::Builder::disownFragmentUrisPerNode() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text, ::capnp::Kind::BLOB>, ::capnp::Kind::LIST>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>> +ConsolidationPlanResponse::Builder::disownFragmentUrisPerNode() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::capnp::List<::capnp::Text, ::capnp::Kind::BLOB>, + ::capnp::Kind::LIST>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } inline bool QueryChannel::Reader::getDefault() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _reader.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline bool QueryChannel::Builder::getDefault() { - return _builder.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); + return _builder.getDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS); } inline void QueryChannel::Builder::setDefault(bool value) { - _builder.setDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); + _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool QueryChannel::Reader::hasAggregates() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool QueryChannel::Builder::hasAggregates() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>::Reader QueryChannel::Reader::getAggregates() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>::Builder QueryChannel::Builder::getAggregates() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void QueryChannel::Builder::setAggregates( ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>::Builder QueryChannel::Builder::initAggregates(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>::Reader +QueryChannel::Reader::getAggregates() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>::Builder +QueryChannel::Builder::getAggregates() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void QueryChannel::Builder::setAggregates( + ::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>::Builder +QueryChannel::Builder::initAggregates(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void QueryChannel::Builder::adoptAggregates( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>> QueryChannel::Builder::disownAggregates() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::Aggregate, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>> +QueryChannel::Builder::disownAggregates() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::Aggregate, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } inline bool Aggregate::Reader::hasOutputFieldName() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool Aggregate::Builder::hasOutputFieldName() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Aggregate::Reader::getOutputFieldName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Aggregate::Reader::getOutputFieldName() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Aggregate::Builder::getOutputFieldName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Aggregate::Builder::getOutputFieldName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void Aggregate::Builder::setOutputFieldName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void Aggregate::Builder::setOutputFieldName( + ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Aggregate::Builder::initOutputFieldName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Aggregate::Builder::initOutputFieldName( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void Aggregate::Builder::adoptOutputFieldName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Aggregate::Builder::disownOutputFieldName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +Aggregate::Builder::disownOutputFieldName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool Aggregate::Reader::hasInputFieldName() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool Aggregate::Builder::hasInputFieldName() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Aggregate::Reader::getInputFieldName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Aggregate::Reader::getInputFieldName() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Aggregate::Builder::getInputFieldName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Aggregate::Builder::getInputFieldName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline void Aggregate::Builder::setInputFieldName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); +inline void Aggregate::Builder::setInputFieldName(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Aggregate::Builder::initInputFieldName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Aggregate::Builder::initInputFieldName( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + size); } inline void Aggregate::Builder::adoptInputFieldName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Aggregate::Builder::disownInputFieldName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> +Aggregate::Builder::disownInputFieldName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool Aggregate::Reader::hasName() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } inline bool Aggregate::Builder::hasName() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader Aggregate::Reader::getName() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader Aggregate::Reader::getName() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder Aggregate::Builder::getName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder Aggregate::Builder::getName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline void Aggregate::Builder::setName( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), value); +inline void Aggregate::Builder::setName(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder Aggregate::Builder::initName(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder Aggregate::Builder::initName(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + size); } inline void Aggregate::Builder::adoptName( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> Aggregate::Builder::disownName() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> Aggregate::Builder::disownName() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS)); } -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Which CurrentDomain::Reader::which() const { - return _reader.getDataField( - ::capnp::bounded<2>() * ::capnp::ELEMENTS); +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Which +CurrentDomain::Reader::which() const { + return _reader.getDataField(::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::tiledb::sm::serialization::capnp::CurrentDomain::Which CurrentDomain::Builder::which() { +inline ::tiledb::sm::serialization::capnp::CurrentDomain::Which +CurrentDomain::Builder::which() { return _builder.getDataField( ::capnp::bounded<2>() * ::capnp::ELEMENTS); } -inline ::uint32_t CurrentDomain::Reader::getVersion() const { - return _reader.getDataField< ::uint32_t>( +inline ::uint32_t CurrentDomain::Reader::getVersion() const { + return _reader.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::uint32_t CurrentDomain::Builder::getVersion() { - return _builder.getDataField< ::uint32_t>( +inline ::uint32_t CurrentDomain::Builder::getVersion() { + return _builder.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void CurrentDomain::Builder::setVersion( ::uint32_t value) { - _builder.setDataField< ::uint32_t>( +inline void CurrentDomain::Builder::setVersion(::uint32_t value) { + _builder.setDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } inline bool CurrentDomain::Reader::hasType() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool CurrentDomain::Builder::hasType() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline ::capnp::Text::Reader CurrentDomain::Reader::getType() const { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Reader CurrentDomain::Reader::getType() const { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline ::capnp::Text::Builder CurrentDomain::Builder::getType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Text::Builder CurrentDomain::Builder::getType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } -inline void CurrentDomain::Builder::setType( ::capnp::Text::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); +inline void CurrentDomain::Builder::setType(::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers<::capnp::Text>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); } -inline ::capnp::Text::Builder CurrentDomain::Builder::initType(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); +inline ::capnp::Text::Builder CurrentDomain::Builder::initType( + unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::Text>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void CurrentDomain::Builder::adoptType( - ::capnp::Orphan< ::capnp::Text>&& value) { - ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::Orphan<::capnp::Text>&& value) { + ::capnp::_::PointerHelpers<::capnp::Text>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::capnp::Text> CurrentDomain::Builder::disownType() { - return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::capnp::Text> CurrentDomain::Builder::disownType() { + return ::capnp::_::PointerHelpers<::capnp::Text>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); } inline bool CurrentDomain::Reader::isEmptyCurrentDomain() const { @@ -25421,23 +34698,26 @@ inline bool CurrentDomain::Reader::isEmptyCurrentDomain() const { inline bool CurrentDomain::Builder::isEmptyCurrentDomain() { return which() == CurrentDomain::EMPTY_CURRENT_DOMAIN; } -inline ::capnp::Void CurrentDomain::Reader::getEmptyCurrentDomain() const { - KJ_IREQUIRE((which() == CurrentDomain::EMPTY_CURRENT_DOMAIN), - "Must check which() before get()ing a union member."); - return _reader.getDataField< ::capnp::Void>( +inline ::capnp::Void CurrentDomain::Reader::getEmptyCurrentDomain() const { + KJ_IREQUIRE( + (which() == CurrentDomain::EMPTY_CURRENT_DOMAIN), + "Must check which() before get()ing a union member."); + return _reader.getDataField<::capnp::Void>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::capnp::Void CurrentDomain::Builder::getEmptyCurrentDomain() { - KJ_IREQUIRE((which() == CurrentDomain::EMPTY_CURRENT_DOMAIN), - "Must check which() before get()ing a union member."); - return _builder.getDataField< ::capnp::Void>( +inline ::capnp::Void CurrentDomain::Builder::getEmptyCurrentDomain() { + KJ_IREQUIRE( + (which() == CurrentDomain::EMPTY_CURRENT_DOMAIN), + "Must check which() before get()ing a union member."); + return _builder.getDataField<::capnp::Void>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void CurrentDomain::Builder::setEmptyCurrentDomain( ::capnp::Void value) { +inline void CurrentDomain::Builder::setEmptyCurrentDomain(::capnp::Void value) { _builder.setDataField( - ::capnp::bounded<2>() * ::capnp::ELEMENTS, CurrentDomain::EMPTY_CURRENT_DOMAIN); - _builder.setDataField< ::capnp::Void>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, + CurrentDomain::EMPTY_CURRENT_DOMAIN); + _builder.setDataField<::capnp::Void>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } @@ -25448,105 +34728,164 @@ inline bool CurrentDomain::Builder::isNdRectangle() { return which() == CurrentDomain::ND_RECTANGLE; } inline bool CurrentDomain::Reader::hasNdRectangle() const { - if (which() != CurrentDomain::ND_RECTANGLE) return false; - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); + if (which() != CurrentDomain::ND_RECTANGLE) + return false; + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); } inline bool CurrentDomain::Builder::hasNdRectangle() { - if (which() != CurrentDomain::ND_RECTANGLE) return false; - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::tiledb::sm::serialization::capnp::NDRectangle::Reader CurrentDomain::Reader::getNdRectangle() const { - KJ_IREQUIRE((which() == CurrentDomain::ND_RECTANGLE), - "Must check which() before get()ing a union member."); - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NDRectangle>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::NDRectangle::Builder CurrentDomain::Builder::getNdRectangle() { - KJ_IREQUIRE((which() == CurrentDomain::ND_RECTANGLE), - "Must check which() before get()ing a union member."); - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NDRectangle>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void CurrentDomain::Builder::setNdRectangle( ::tiledb::sm::serialization::capnp::NDRectangle::Reader value) { + if (which() != CurrentDomain::ND_RECTANGLE) + return false; + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::tiledb::sm::serialization::capnp::NDRectangle::Reader +CurrentDomain::Reader::getNdRectangle() const { + KJ_IREQUIRE( + (which() == CurrentDomain::ND_RECTANGLE), + "Must check which() before get()ing a union member."); + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::NDRectangle>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::NDRectangle::Builder +CurrentDomain::Builder::getNdRectangle() { + KJ_IREQUIRE( + (which() == CurrentDomain::ND_RECTANGLE), + "Must check which() before get()ing a union member."); + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::NDRectangle>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void CurrentDomain::Builder::setNdRectangle( + ::tiledb::sm::serialization::capnp::NDRectangle::Reader value) { _builder.setDataField( ::capnp::bounded<2>() * ::capnp::ELEMENTS, CurrentDomain::ND_RECTANGLE); - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NDRectangle>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::NDRectangle>:: + set(_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); } -inline ::tiledb::sm::serialization::capnp::NDRectangle::Builder CurrentDomain::Builder::initNdRectangle() { +inline ::tiledb::sm::serialization::capnp::NDRectangle::Builder +CurrentDomain::Builder::initNdRectangle() { _builder.setDataField( ::capnp::bounded<2>() * ::capnp::ELEMENTS, CurrentDomain::ND_RECTANGLE); - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NDRectangle>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::NDRectangle>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline void CurrentDomain::Builder::adoptNdRectangle( - ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NDRectangle>&& value) { + ::capnp::Orphan<::tiledb::sm::serialization::capnp::NDRectangle>&& value) { _builder.setDataField( ::capnp::bounded<2>() * ::capnp::ELEMENTS, CurrentDomain::ND_RECTANGLE); - ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NDRectangle>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); + ::capnp::_::PointerHelpers<::tiledb::sm::serialization::capnp::NDRectangle>:: + adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); } -inline ::capnp::Orphan< ::tiledb::sm::serialization::capnp::NDRectangle> CurrentDomain::Builder::disownNdRectangle() { - KJ_IREQUIRE((which() == CurrentDomain::ND_RECTANGLE), - "Must check which() before get()ing a union member."); - return ::capnp::_::PointerHelpers< ::tiledb::sm::serialization::capnp::NDRectangle>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::NDRectangle> +CurrentDomain::Builder::disownNdRectangle() { + KJ_IREQUIRE( + (which() == CurrentDomain::ND_RECTANGLE), + "Must check which() before get()ing a union member."); + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::NDRectangle>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } inline bool NDRectangle::Reader::hasNdranges() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } inline bool NDRectangle::Builder::hasNdranges() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Reader NDRectangle::Reader::getNdranges() const { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Builder NDRectangle::Builder::getNdranges() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void NDRectangle::Builder::setNdranges( ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>::Builder NDRectangle::Builder::initNdranges(unsigned int size) { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), size); + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>::Reader +NDRectangle::Reader::getNdranges() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>::Builder +NDRectangle::Builder::getNdranges() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void NDRectangle::Builder::setNdranges( + ::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>::Builder +NDRectangle::Builder::initNdranges(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); } inline void NDRectangle::Builder::adoptNdranges( - ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>> NDRectangle::Builder::disownNdranges() { - return ::capnp::_::PointerHelpers< ::capnp::List< ::tiledb::sm::serialization::capnp::SubarrayRanges, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} - -inline ::tiledb::sm::serialization::capnp::ObjectType ObjectInfoResponse::Reader::getObjectType() const { - return _reader.getDataField< ::tiledb::sm::serialization::capnp::ObjectType>( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>> +NDRectangle::Builder::disownNdranges() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::SubarrayRanges, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} + +inline ::tiledb::sm::serialization::capnp::ObjectType +ObjectInfoResponse::Reader::getObjectType() const { + return _reader.getDataField<::tiledb::sm::serialization::capnp::ObjectType>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline ::tiledb::sm::serialization::capnp::ObjectType ObjectInfoResponse::Builder::getObjectType() { - return _builder.getDataField< ::tiledb::sm::serialization::capnp::ObjectType>( +inline ::tiledb::sm::serialization::capnp::ObjectType +ObjectInfoResponse::Builder::getObjectType() { + return _builder.getDataField<::tiledb::sm::serialization::capnp::ObjectType>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); } -inline void ObjectInfoResponse::Builder::setObjectType( ::tiledb::sm::serialization::capnp::ObjectType value) { - _builder.setDataField< ::tiledb::sm::serialization::capnp::ObjectType>( +inline void ObjectInfoResponse::Builder::setObjectType( + ::tiledb::sm::serialization::capnp::ObjectType value) { + _builder.setDataField<::tiledb::sm::serialization::capnp::ObjectType>( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -} // namespace -} // namespace -} // namespace -} // namespace +} // namespace capnp +} // namespace serialization +} // namespace sm +} // namespace tiledb CAPNP_END_HEADER - From 12b0b1ef4d2bfb2943fadf2bbcd38049ee93a72c Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 2 Jan 2025 12:45:53 -0500 Subject: [PATCH 094/228] Tile order accounting against memory budget --- test/src/unit-sparse-global-order-reader.cc | 9 +- .../readers/sparse_global_order_reader.cc | 102 +++++++++++++++--- .../query/readers/sparse_index_reader_base.h | 4 + 3 files changed, 97 insertions(+), 18 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index fc90b20f7b6..f8afb45f362 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -1034,8 +1034,13 @@ static bool can_complete_in_memory_budget( tiledb_ctx_t* ctx, const char* array_uri, const Instance& instance) { CApiArray array(ctx, array_uri, TILEDB_READ); - // TODO: verify that the conditions for the error are correct const auto& fragment_metadata = array->array()->fragment_metadata(); + + uint64_t num_tiles = 0; + for (const auto& fragment : fragment_metadata) { + num_tiles += fragment->tile_num(); + } + for (const auto& fragment : fragment_metadata) { const_cast(fragment.get()) ->loaded_metadata() @@ -1116,7 +1121,7 @@ static bool can_complete_in_memory_budget( // and take more memory const uint64_t coords_budget = std::stoi(instance.memory.total_budget_) * std::stod(instance.memory.ratio_coords_); - uint64_t active_tile_size = 0; + uint64_t active_tile_size = sizeof(RT) * num_tiles; uint64_t next_tile_size = 0; while (active_tile_size + next_tile_size < coords_budget && !mbr_lower_bound.empty()) { diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index a0db8a4639b..c5214c63e4d 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -73,11 +73,17 @@ class SparseGlobalOrderReaderInternalError /** * Encapsulates the input to the preprocess tile merge, and the * merge output future for polling. - * - * It is necessary to - * Holds */ struct PreprocessTileMergeFuture { + using MemoryCounter = std::atomic; + + PreprocessTileMergeFuture(MemoryCounter& memory_used) + : memory_used_(memory_used) { + } + + /** memory used for result tile IDs */ + MemoryCounter& memory_used_; + /** merge configuration, looks unused but must out-live the merge future */ algorithm::ParallelMergeOptions merge_options_; @@ -92,13 +98,32 @@ struct PreprocessTileMergeFuture { /** the merge future */ std::optional> merge_; + private: + void free_input() { + for (auto& fragment : fragment_result_tiles_) { + const auto num_tiles = fragment.size(); + fragment.clear(); + memory_used_ -= sizeof(ResultTileId) * num_tiles; + } + fragment_result_tiles_.clear(); + fragment_result_tile_spans_.clear(); + } + + public: std::optional await() { auto ret = merge_.value()->await(); if (merge_.value()->finished()) { - fragment_result_tiles_.clear(); + free_input(); } return ret; } + + void block() { + if (merge_.has_value()) { + merge_.value()->block(); + free_input(); + } + } }; /* ****************************** */ @@ -144,8 +169,15 @@ SparseGlobalOrderReader::SparseGlobalOrderReader( template bool SparseGlobalOrderReader::incomplete() const { - return !read_state_.done_adding_result_tiles() || - memory_used_for_coords_total_ != 0; + if (!read_state_.done_adding_result_tiles()) { + return true; + } else if (!preprocess_tile_order_.enabled_) { + return memory_used_for_coords_total_ != 0; + } else if (preprocess_tile_order_.has_more_tiles()) { + return false; + } else { + return memory_used_for_coords_total_ != 0; + } } template @@ -206,7 +238,7 @@ Status SparseGlobalOrderReader::dowork() { std::optional preprocess_future; if (preprocess_tile_order_.enabled_ && preprocess_tile_order_.tiles_.empty()) { - preprocess_future = PreprocessTileMergeFuture(); + preprocess_future.emplace(memory_used_for_coords_total_); preprocess_compute_result_tile_order(preprocess_future.value()); } @@ -312,7 +344,7 @@ Status SparseGlobalOrderReader::dowork() { // wait for tile merge to complete so we don't have to keep this // state around for the next iteration, and if this errors for // some reason we should return that - preprocess_future->merge_.value()->block(); + preprocess_future->block(); } return Status::Ok(); @@ -449,6 +481,21 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( // so that we could be closer to a proper LIMIT subarray_.load_relevant_fragment_rtrees(&resources_.compute_tp()); + auto try_reserve = [&](unsigned f, size_t num_tiles) { + memory_used_for_coords_total_ += sizeof(ResultTileId) * num_tiles; + + if (memory_used_for_coords_total_ > memory_budget_.coordinates_budget()) { + return Status_QueryError( + "Cannot allocate space for preprocess result tile ID list, " + "increase memory budget: total budget = " + + std::to_string(memory_budget_.coordinates_budget()) + + ", memory needed >= " + + std::to_string(memory_used_for_coords_total_)); + } + fragment_result_tiles[f].reserve(num_tiles); + return Status::Ok(); + }; + // first apply subarray (in parallel) if (!subarray_.is_set()) { for (const auto& f : relevant_fragments) { @@ -457,7 +504,9 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( auto populate_fragment_relevant_tiles = parallel_for( &resources_.compute_tp(), 0, num_relevant_fragments, [&](unsigned rf) { const unsigned f = relevant_fragments[rf]; - fragment_result_tiles[f].reserve(fragment_metadata_[f]->tile_num()); + const unsigned num_tiles = fragment_metadata_[f]->tile_num(); + RETURN_NOT_OK(try_reserve(f, num_tiles)); + for (uint64_t t = 0; t < fragment_metadata_[f]->tile_num(); t++) { fragment_result_tiles[f].push_back( ResultTileId{.fragment_idx_ = f, .tile_idx_ = t}); @@ -478,7 +527,8 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( for (const auto& tile_range : fragment_tile_ranges) { num_qualifying_tiles += 1 + tile_range.second - tile_range.first; } - fragment_result_tiles[f].reserve(num_qualifying_tiles); + + RETURN_NOT_OK(try_reserve(f, num_qualifying_tiles)); for (auto tile_range = fragment_tile_ranges.rbegin(); tile_range != fragment_tile_ranges.rend(); @@ -507,6 +557,15 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( num_result_tiles += fragment.size(); } + memory_used_for_coords_total_ += sizeof(ResultTileId) * num_result_tiles; + if (memory_used_for_coords_total_ > memory_budget_.coordinates_budget()) { + throw SparseGlobalOrderReaderException( + "Cannot allocate space for preprocess result tile ID list, " + "increase memory budget: total budget = " + + std::to_string(memory_budget_.coordinates_budget()) + + ", memory needed = " + std::to_string(memory_used_for_coords_total_)); + } + /* then do parallel merge */ auto& fragment_result_tile_spans = future.fragment_result_tile_spans_; fragment_result_tile_spans.reserve(fragment_result_tiles.size()); @@ -779,7 +838,7 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( const auto num_fragments = fragment_metadata_.size(); const auto num_dims = array_schema_.dim_num(); - if (preprocess_tile_order_.cursor_ < preprocess_tile_order_.tiles_.size()) { + if (preprocess_tile_order_.has_more_tiles()) { size_t rt = preprocess_tile_order_.cursor_; size_t rt_merge_bound = (merge_future.has_value() ? rt : preprocess_tile_order_.tiles_.size()); @@ -826,6 +885,14 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( } if (!canProgress) { + // first try to free some memory by waiting for merge if it is ongoing + if (merge_future.has_value()) { + merge_future->block(); + merge_future.reset(); + rt_merge_bound = preprocess_tile_order_.tiles_.size(); + continue; + } + // this means we cannot safely produce any results const auto tiles_size = get_coord_tiles_size(num_dims, f, t); throw SparseGlobalOrderReaderException( @@ -849,8 +916,7 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( // update position for next iteration preprocess_tile_order_.cursor_ = rt; - if (preprocess_tile_order_.cursor_ == - preprocess_tile_order_.tiles_.size()) { + if (!preprocess_tile_order_.has_more_tiles()) { // TODO: original version sets a flag in tmp_read_state_ on a per-fragment // basis, does that have any effect other than computing this? read_state_.set_done_adding_result_tiles(true); @@ -861,6 +927,11 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( for (unsigned f = 0; f < num_fragments; f++) { tmp_read_state_.set_all_tiles_loaded(f); } + + // NB: merge must have completed for this condition to be satisfied + const auto num_tiles = preprocess_tile_order_.tiles_.size(); + preprocess_tile_order_.tiles_.clear(); + memory_used_for_coords_total_ -= sizeof(ResultTileId) * num_tiles; } } } @@ -1196,7 +1267,7 @@ AddNextCellResult SparseGlobalOrderReader::add_next_cell_to_queue( // If the cell value exceeds the lower bound of the un-populated result // tiles then it is not correct to emit it; hopefully we cleared out // a tile somewhere and trying again will make progress - if (preprocess_tile_order_.cursor_ < preprocess_tile_order_.tiles_.size()) { + if (preprocess_tile_order_.has_more_tiles()) { const auto& next_global_order_tile = preprocess_tile_order_.tiles_[preprocess_tile_order_.cursor_]; const auto& emit_bound = @@ -1460,8 +1531,7 @@ SparseGlobalOrderReader::merge_result_cell_slabs( // Compute the length of the cell slab. uint64_t length = 1; if (to_process.has_next_ || single_cell_only) { - if (preprocess_tile_order_.cursor_ < - preprocess_tile_order_.tiles_.size()) { + if (preprocess_tile_order_.has_more_tiles()) { // the cell slab may overlap the lower bound of tiles which aren't in // the queue yet const auto& next_global_order_tile = diff --git a/tiledb/sm/query/readers/sparse_index_reader_base.h b/tiledb/sm/query/readers/sparse_index_reader_base.h index f037f46db48..7a774ba175e 100644 --- a/tiledb/sm/query/readers/sparse_index_reader_base.h +++ b/tiledb/sm/query/readers/sparse_index_reader_base.h @@ -302,6 +302,10 @@ struct PreprocessTileOrder { bool enabled_; size_t cursor_; std::vector tiles_; + + bool has_more_tiles() const { + return cursor_ < tiles_.size(); + } }; /** From 782900a6b9eeff13c2f7a388212f2714835a229e Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 2 Jan 2025 13:06:23 -0500 Subject: [PATCH 095/228] Do not shrink by default for rapidcheck 1D, 2D tests --- test/src/unit-sparse-global-order-reader.cc | 11 ++--- test/support/tdb_rapidcheck.h | 45 +++++++++++++++++++++ 2 files changed, 51 insertions(+), 5 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index f8afb45f362..737e1c5a8dd 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -64,6 +64,7 @@ using tiledb::sm::Datatype; using tiledb::test::tdbrc::AttributeType; using tiledb::test::tdbrc::DimensionType; using tiledb::test::tdbrc::FragmentType; +using tiledb::test::tdbrc::NonShrinking; namespace rc { Gen>> make_subarray_1d( @@ -3001,9 +3002,9 @@ void show(const FxRun2D& instance, std::ostream& os) { TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: rapidcheck 1d", - "[sparse-global-order]") { + "[sparse-global-order][rapidcheck]") { SECTION("Rapidcheck") { - rc::prop("rapidcheck arbitrary 1d", [this](FxRun1D instance) { + rc::prop("rapidcheck arbitrary 1d", [this](NonShrinking instance) { run(instance); }); } @@ -3012,10 +3013,10 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: rapidcheck 2d", - "[sparse-global-order]") { + "[sparse-global-order][rapidcheck]") { SECTION("rapidcheck") { - rc::prop("rapidcheck arbitrary 2d", [this](FxRun2D instance) { - run(instance); + rc::prop("rapidcheck arbitrary 2d", [this](NonShrinking instance) { + run(instance); }); } } diff --git a/test/support/tdb_rapidcheck.h b/test/support/tdb_rapidcheck.h index a55978533a7..81d39e74a9f 100644 --- a/test/support/tdb_rapidcheck.h +++ b/test/support/tdb_rapidcheck.h @@ -122,4 +122,49 @@ struct AsserterRapidcheck {}; } \ } while (0) +namespace tiledb::test::tdbrc { + +/** + * Wrapper struct whose `Arbitrary` specialization returns + * a non-shrinking generator. + * + * This is meant to be used for generators which have a + * very very large shrinking space, such that by default + * we do not want to shrink (e.g. in CI - instead we want + * to capture the seed immediately and file a bug report + * where the assignee can kick off the shrinking). + */ +template +struct NonShrinking { + NonShrinking(T&& inner) + : inner_(inner) { + } + + T inner_; + + operator T&() { + return inner_; + } + + operator const T&() const { + return inner_; + } +}; + +} // namespace tiledb::test::tdbrc + +namespace rc { +template +struct Arbitrary> { + static Gen> arbitrary() { + auto inner = gen::noShrink(gen::arbitrary()); + return gen::apply( + [](T inner) { + return tiledb::test::tdbrc::NonShrinking(std::move(inner)); + }, + inner); + } +}; +} // namespace rc + #endif // TILEDB_MISC_TDB_RAPIDCHECK_H From 0012cb8200d2341baa379a3ab36100b50a9f480d Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 2 Jan 2025 13:15:17 -0500 Subject: [PATCH 096/228] tdb::make_shared for ResultTileCmp --- tiledb/sm/query/readers/sparse_global_order_reader.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index c5214c63e4d..1ce614e5bee 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -614,8 +614,8 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( }; { - std::shared_ptr cmp = std::make_shared( - array_schema_.domain(), fragment_metadata_); + std::shared_ptr cmp = tdb::make_shared( + "ResultTileCmp", array_schema_.domain(), fragment_metadata_); future.cmp_ = std::static_pointer_cast(cmp); } From 34a9a748656e71ec1abc04cc236a1618db5887f3 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 2 Jan 2025 16:07:41 -0500 Subject: [PATCH 097/228] Self review cleaning: remove FxFragment1D, tuple.h --- test/src/unit-sparse-global-order-reader.cc | 131 ++++++++------------ test/support/rapidcheck/array.h | 103 ++++----------- test/support/tuple.h | 127 +++++++++++++++++++ 3 files changed, 201 insertions(+), 160 deletions(-) create mode 100644 test/support/tuple.h diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 737e1c5a8dd..e09881bc08d 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -75,35 +75,6 @@ Gen>> make_subarray_1d( /* STRUCT DEFINITION */ /* ********************************* */ -/** - * Contains the data for a single fragment - * of the 1D array created by `CSparseGlobalOrderFx` - */ -struct FxFragment1D { - std::vector coords; - std::vector atts; - - uint64_t size() const { - return coords.size(); - } - - std::tuple&> dimensions() { - return std::tuple&>(coords); - } - - std::tuple&> dimensions() const { - return std::tuple&>(coords); - } - - std::tuple&> attributes() { - return std::tuple&>(atts); - } - - std::tuple&> attributes() const { - return std::tuple&>(atts); - } -}; - struct MemoryBudget { std::string total_budget_; std::string ratio_tile_ranges_; @@ -146,7 +117,8 @@ struct DefaultArray1DConfig { * An instance of one-dimension array input to `CSparseGlobalOrderFx::run` */ struct FxRun1D { - using FragmentType = FxFragment1D; + using FragmentType = tdbrc::Fragment1D; + uint64_t num_user_cells; std::vector fragments; @@ -179,7 +151,7 @@ struct FxRun1D { if (subarray.empty()) { return true; } else { - const int coord = fragment.coords[record]; + const int coord = fragment.dim_[record]; for (const auto& range : subarray) { if (range.contains(coord)) { return true; @@ -1399,25 +1371,27 @@ TEST_CASE_METHOD( const std::vector>& subarray = std::vector>()) { // Write a fragment F0 with unique coordinates - struct FxFragment1D fragment0; - fragment0.coords.resize(fragment_size); - std::iota(fragment0.coords.begin(), fragment0.coords.end(), 1); + tdbrc::Fragment1D fragment0; + fragment0.dim_.resize(fragment_size); + std::iota(fragment0.dim_.begin(), fragment0.dim_.end(), 1); // Write a fragment F1 with lots of duplicates // [100,100,100,100,100,101,101,101,101,101,102,102,102,102,102,...] - struct FxFragment1D fragment1; - fragment1.coords.resize(fragment0.coords.size()); - for (size_t i = 0; i < fragment1.coords.size(); i++) { - fragment1.coords[i] = - static_cast(i / 10) + (fragment0.coords.size() / 2); + tdbrc::Fragment1D fragment1; + fragment1.dim_.resize(fragment0.dim_.size()); + for (size_t i = 0; i < fragment1.dim_.size(); i++) { + fragment1.dim_[i] = + static_cast(i / 10) + (fragment0.dim_.size() / 2); } // atts are whatever - fragment0.atts.resize(fragment0.coords.size()); - std::iota(fragment0.atts.begin(), fragment0.atts.end(), 0); - fragment1.atts.resize(fragment1.coords.size()); - std::iota( - fragment1.atts.begin(), fragment1.atts.end(), fragment0.coords.size()); + auto& f0atts = std::get<0>(fragment0.atts_); + f0atts.resize(fragment0.dim_.size()); + std::iota(f0atts.begin(), f0atts.end(), 0); + + auto& f1atts = std::get<0>(fragment1.atts_); + f1atts.resize(fragment1.dim_.size()); + std::iota(f1atts.begin(), f1atts.end(), fragment0.dim_.size()); struct FxRun1D instance; instance.fragments.push_back(fragment0); @@ -1471,29 +1445,30 @@ TEST_CASE_METHOD( size_t fragment_size, size_t num_user_cells, const std::vector>& subarray = {}) { - struct FxFragment1D fragment0; - struct FxFragment1D fragment1; + tdbrc::Fragment1D fragment0; + tdbrc::Fragment1D fragment1; // Write a fragment F0 with tiles [1,3][3,5][5,7][7,9]... - fragment0.coords.resize(fragment_size); - fragment0.coords[0] = 1; - for (size_t i = 1; i < fragment0.coords.size(); i++) { - fragment0.coords[i] = 1 + 2 * ((i + 1) / 2); + fragment0.dim_.resize(fragment_size); + fragment0.dim_[0] = 1; + for (size_t i = 1; i < fragment0.dim_.size(); i++) { + fragment0.dim_[i] = 1 + 2 * ((i + 1) / 2); } // Write a fragment F1 with tiles [2,4][4,6][6,8][8,10]... - fragment1.coords.resize(fragment0.coords.size()); - for (size_t i = 0; i < fragment1.coords.size(); i++) { - fragment1.coords[i] = fragment0.coords[i] + 1; + fragment1.dim_.resize(fragment0.dim_.size()); + for (size_t i = 0; i < fragment1.dim_.size(); i++) { + fragment1.dim_[i] = fragment0.dim_[i] + 1; } // atts don't really matter - fragment0.atts.resize(fragment0.coords.size()); - std::iota(fragment0.atts.begin(), fragment0.atts.end(), 0); + auto& f0atts = std::get<0>(fragment0.atts_); + f0atts.resize(fragment0.dim_.size()); + std::iota(f0atts.begin(), f0atts.end(), 0); - fragment1.atts.resize(fragment1.coords.size()); - std::iota( - fragment1.atts.begin(), fragment1.atts.end(), fragment0.atts.size()); + auto& f1atts = std::get<0>(fragment1.atts_); + f1atts.resize(fragment1.dim_.size()); + std::iota(f1atts.begin(), f1atts.end(), f0atts.size()); struct FxRun1D instance; instance.fragments.push_back(fragment0); @@ -1580,18 +1555,16 @@ TEST_CASE_METHOD( instance.memory.ratio_array_data_ = "0.6"; for (size_t f = 0; f < num_fragments; f++) { - FxFragment1D fragment; - fragment.coords.resize(fragment_size); + tdbrc::Fragment1D fragment; + fragment.dim_.resize(fragment_size); std::iota( - fragment.coords.begin(), - fragment.coords.end(), + fragment.dim_.begin(), + fragment.dim_.end(), instance.array.dimension.domain.lower_bound + f); - fragment.atts.resize(fragment_size); - std::iota( - fragment.atts.begin(), - fragment.atts.end(), - fragment_size * num_fragments); + auto& atts = std::get<0>(fragment.atts_); + atts.resize(fragment_size); + std::iota(atts.begin(), atts.end(), fragment_size * num_fragments); instance.fragments.push_back(fragment); } @@ -2782,19 +2755,15 @@ struct Arbitrary { auto fragments = gen::mapcat(dimension, [](tdbrc::Dimension dimension) { - auto fragment = gen::map( - rc::make_fragment_1d(dimension.domain), - [](tdbrc::Fragment1D fragment) { - return FxFragment1D{ - .coords = fragment.dim_, - .atts = std::get<0>(fragment.atts_)}; - }); + auto fragment = + rc::make_fragment_1d(dimension.domain); return gen::tuple( gen::just(dimension), make_subarray_1d(dimension.domain), gen::nonEmpty( - gen::container>(fragment))); + gen::container>>( + fragment))); }); auto num_user_cells = gen::inRange(1, 8 * 1024 * 1024); @@ -2803,7 +2772,7 @@ struct Arbitrary { [](std::tuple< tdbrc::Dimension, std::vector>, - std::vector> fragments, + std::vector>> fragments, int num_user_cells) { FxRun1D instance; std::tie( @@ -2902,12 +2871,12 @@ void show(const FxRun1D& instance, std::ostream& os) { os << "\t\t{" << std::endl; os << "\t\t\t\"coords\": [" << std::endl; os << "\t\t\t\t"; - show(fragment.coords, os); + show(fragment.dim_, os); os << std::endl; os << "\t\t\t], " << std::endl; os << "\t\t\t\"atts\": [" << std::endl; os << "\t\t\t\t"; - show(fragment.atts, os); + show(std::get<0>(fragment.atts_), os); os << std::endl; os << "\t\t\t] " << std::endl; os << "\t\t}"; @@ -3031,9 +3000,9 @@ TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: multi-range subarray signal", "[sparse-global-order]") { - FxFragment1D fragment0; - fragment0.coords.push_back(1); - fragment0.atts.push_back(1); + tdbrc::Fragment1D fragment0; + fragment0.dim_.push_back(1); + std::get<0>(fragment0.atts_).push_back(1); FxRun1D instance; instance.fragments.push_back(fragment0); diff --git a/test/support/rapidcheck/array.h b/test/support/rapidcheck/array.h index e3835d63c38..585e465bb90 100644 --- a/test/support/rapidcheck/array.h +++ b/test/support/rapidcheck/array.h @@ -39,6 +39,7 @@ #include "tiledb/type/range/range.h" #include +#include #include #include @@ -51,6 +52,10 @@ class Dimension; namespace tiledb::test::tdbrc { +/** + * Adapts a `std::tuple` whose fields are all `GlobalCellCmp` + * to itself be `GlobalCellCmp`. + */ template struct global_cell_cmp_std_tuple { global_cell_cmp_std_tuple(const StdTuple& tup) @@ -100,6 +105,13 @@ template concept AttributeType = requires(const T& coord) { typename ::rc::Arbitrary; }; +/** + * Describes types which can be used as columnar data fragment input. + * + * Methods `dimensions` and `attributes` return tuples whose fields are each + * `std::vector` and `std::vector` + * respectively. + */ template concept FragmentType = requires(const T& fragment) { { fragment.size() } -> std::convertible_to; @@ -184,6 +196,18 @@ struct Fragment1D { }, atts_); } + + std::tuple&> dimensions() { + return std::tuple&>(dim_); + } + + std::tuple&...> attributes() { + return std::apply( + [](std::vector&... attribute) { + return std::tuple&...>(attribute...); + }, + atts_); + } }; /** @@ -227,85 +251,6 @@ struct Fragment2D { } // namespace tiledb::test::tdbrc -namespace stdx { - -/** - * @return the transposition of row-oriented tuples into column-oriented tuples - */ -template -std::tuple...> transpose(std::vector> rows) { - std::tuple...> cols; - - std::apply( - [&](std::vector&... col) { (col.reserve(rows.size()), ...); }, cols); - - for (size_t i = 0; i < rows.size(); i++) { - std::apply( - [&](std::vector&... col) { - std::apply([&](Ts... cell) { (col.push_back(cell), ...); }, rows[i]); - }, - cols); - } - - return cols; -} - -template -std::tuple&...> reference_tuple( - const std::tuple& tuple) { - return std::apply( - [](const std::decay_t&... field) { - return std::forward_as_tuple(field...); - }, - tuple); -} - -template -void extend( - std::tuple&...>& dest, - std::tuple&...> src) { - std::apply( - [&](std::vector&... dest_col) { - std::apply( - [&](const std::vector&... src_col) { - (dest_col.reserve(dest_col.size() + src_col.size()), ...); - (dest_col.insert(dest_col.end(), src_col.begin(), src_col.end()), - ...); - }, - src); - }, - dest); -} - -template -std::tuple...> select( - std::tuple&...> records, - std::span idxs) { - std::tuple...> selected; - - auto select_into = [&idxs]( - std::vector& dest, std::span src) { - dest.reserve(idxs.size()); - for (auto i : idxs) { - dest.push_back(src[i]); - } - }; - - std::apply( - [&](std::vector&... sel) { - std::apply( - [&](const std::vector&... col) { - (select_into.template operator()(sel, std::span(col)), ...); - }, - records); - }, - selected); - - return selected; -} - -} // namespace stdx - namespace rc { using namespace tiledb::test::tdbrc; diff --git a/test/support/tuple.h b/test/support/tuple.h new file mode 100644 index 00000000000..d6336959c89 --- /dev/null +++ b/test/support/tuple.h @@ -0,0 +1,127 @@ +/** + * @file test/support/tuple.h + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2024 TileDB, 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. + * + * @section DESCRIPTION + * + * This file defines functions for manipulating `std::tuple`. + */ + +#ifndef TILEDB_TEST_SUPPORT_TUPLE_H +#define TILEDB_TEST_SUPPORT_TUPLE_H + +namespace stdx { + +/** + * @return the transposition of row-oriented tuples into column-oriented tuples + */ +template +std::tuple...> transpose(std::vector> rows) { + std::tuple...> cols; + + std::apply( + [&](std::vector&... col) { (col.reserve(rows.size()), ...); }, cols); + + for (size_t i = 0; i < rows.size(); i++) { + std::apply( + [&](std::vector&... col) { + std::apply([&](Ts... cell) { (col.push_back(cell), ...); }, rows[i]); + }, + cols); + } + + return cols; +} + +/** + * @return a tuple whose fields are const references to the argument's fields + */ +template +std::tuple&...> reference_tuple( + const std::tuple& tuple) { + return std::apply( + [](const std::decay_t&... field) { + return std::forward_as_tuple(field...); + }, + tuple); +} + +/** + * Given two tuples of vectors, extends each of the fields of `dst` + * with the corresponding field of `src`. + */ +template +void extend( + std::tuple&...>& dest, + std::tuple&...> src) { + std::apply( + [&](std::vector&... dest_col) { + std::apply( + [&](const std::vector&... src_col) { + (dest_col.reserve(dest_col.size() + src_col.size()), ...); + (dest_col.insert(dest_col.end(), src_col.begin(), src_col.end()), + ...); + }, + src); + }, + dest); +} + +/** + * Selects the positions given by `idx` from each field of `records` to + * construct a new tuple. + * + * @return a new tuple containing just the selected positions + */ +template +std::tuple...> select( + std::tuple&...> records, + std::span idxs) { + std::tuple...> selected; + + auto select_into = [&idxs]( + std::vector& dest, std::span src) { + dest.reserve(idxs.size()); + for (auto i : idxs) { + dest.push_back(src[i]); + } + }; + + std::apply( + [&](std::vector&... sel) { + std::apply( + [&](const std::vector&... col) { + (select_into.template operator()(sel, std::span(col)), ...); + }, + records); + }, + selected); + + return selected; +} + +} // namespace stdx +#endif From 8441a20ee95f4fc01f16ecd55b95a8b96a800625 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 2 Jan 2025 16:23:42 -0500 Subject: [PATCH 098/228] Fix librapidcheck linking --- test/CMakeLists.txt | 12 ++++++------ tiledb/common/algorithm/test/CMakeLists.txt | 6 ++++++ 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 7297cb54a93..0c95b3fdbf6 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -212,6 +212,12 @@ if (NOT MSVC) add_compile_options(-Wno-deprecated-declarations) endif() +find_library( + LIBRAPIDCHECK + NAMES rapidcheck + REQUIRED +) + # unit test executable add_executable( tiledb_unit EXCLUDE_FROM_ALL @@ -350,12 +356,6 @@ if (LIBFAKETIME) set_property(TEST tiledb_timing_unit PROPERTY ENVIRONMENT_MODIFICATION "FAKETIME=set:2020-12-24 20:30:00;LD_PRELOAD=path_list_append:${LIBFAKETIME}") endif() -find_library( - LIBRAPIDCHECK - NAMES rapidcheck - REQUIRED -) - add_test( NAME "tiledb_unit" COMMAND tiledb_unit --durations=yes diff --git a/tiledb/common/algorithm/test/CMakeLists.txt b/tiledb/common/algorithm/test/CMakeLists.txt index 9ba9b921f41..2fd63dd3a8d 100644 --- a/tiledb/common/algorithm/test/CMakeLists.txt +++ b/tiledb/common/algorithm/test/CMakeLists.txt @@ -26,6 +26,12 @@ include(unit_test) +find_library( + LIBRAPIDCHECK + NAMES rapidcheck + REQUIRED +) + commence(unit_test algorithm) this_target_object_libraries(algorithm) this_target_sources(main.cc unit_parallel_merge.cc) From e83713c12d7a4b6b663c63942628a9a0ee6f21a4 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 2 Jan 2025 17:28:23 -0500 Subject: [PATCH 099/228] comments in unit-sparse-global-order-reader.cc --- test/src/unit-sparse-global-order-reader.cc | 118 ++++++++++++++++++-- 1 file changed, 110 insertions(+), 8 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index e09881bc08d..3c54108057d 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -75,6 +75,10 @@ Gen>> make_subarray_1d( /* STRUCT DEFINITION */ /* ********************************* */ +/** + * Encapsulates memory budget configuration parameters for the sparse global + * order reader + */ struct MemoryBudget { std::string total_budget_; std::string ratio_tile_ranges_; @@ -137,6 +141,9 @@ struct FxRun1D { return array.allow_dups; } + /** + * Add `subarray` to a read query + */ template capi_return_t apply_subarray( tiledb_ctx_t* ctx, tiledb_subarray_t* subarray) const { @@ -147,6 +154,9 @@ struct FxRun1D { return TILEDB_OK; } + /** + * @return true if the cell at index `record` in `fragment` passes `subarray` + */ bool accept(const FragmentType& fragment, int record) const { if (subarray.empty()) { return true; @@ -161,6 +171,9 @@ struct FxRun1D { } } + /** + * @return true if `mbr` intersects with any of the ranges in `subarray` + */ bool intersects(const sm::NDRange& mbr) const { auto accept = [&](const auto& range) { const auto& untyped_mbr = mbr[0]; @@ -172,6 +185,10 @@ struct FxRun1D { std::any_of(subarray.begin(), subarray.end(), accept); } + /** + * @return a new range which is `mbr` with its upper bound "clamped" to that + * of `subarray` + */ sm::NDRange clamp(const sm::NDRange& mbr) const { if (subarray.empty()) { return mbr; @@ -234,6 +251,9 @@ struct FxRun2D { return allow_dups; } + /** + * Add `subarray` to a read query + */ template capi_return_t apply_subarray( tiledb_ctx_t* ctx, tiledb_subarray_t* subarray) const { @@ -276,6 +296,9 @@ struct FxRun2D { return TILEDB_OK; } + /** + * @return true if the cell at index `record` in `fragment` passes `subarray` + */ bool accept(const FragmentType& fragment, int record) const { if (subarray.empty()) { return true; @@ -294,6 +317,9 @@ struct FxRun2D { } } + /** + * @return true if `mbr` intersects with any of the ranges in `subarray` + */ bool intersects(const sm::NDRange& mbr) const { if (subarray.empty()) { return true; @@ -318,6 +344,10 @@ struct FxRun2D { return false; } + /** + * @return a new range which is `mbr` with its upper bound "clamped" to that + * of `subarray` + */ sm::NDRange clamp(const sm::NDRange& mbr) const { sm::NDRange clamped = mbr; for (const auto& range : subarray) { @@ -396,6 +426,9 @@ struct CApiArray { } }; +/** + * Describes types which can be used with `CSparseGlobalOrderFx::run`. + */ template concept InstanceType = requires(const T& instance) { { instance.tile_capacity() } -> std::convertible_to; @@ -637,8 +670,14 @@ void CSparseGlobalOrderFx::write_1d_fragment( tiledb_query_free(&query); } +/** + * Binds variadic field data to a tiledb query + */ template struct query_applicator { + /** + * @return a tuple containing the size of each input field + */ static auto make_field_sizes( const std::tuple fields, uint64_t cell_limit = std::numeric_limits::max()) { @@ -662,6 +701,9 @@ struct query_applicator { fields); } + /** + * Sets buffers on `query` for the variadic `fields` and `fields_sizes` + */ static void set( tiledb_ctx_t* ctx, tiledb_query_t* query, @@ -692,6 +734,9 @@ struct query_applicator { fields); } + /** + * @return the number of cells written into `fields` by a read query + */ static uint64_t num_cells(const auto& fields, const auto& field_sizes) { std::optional num_cells; @@ -720,6 +765,9 @@ struct query_applicator { } }; +/** + * Writes a generic `FragmentType` into the array. + */ template void CSparseGlobalOrderFx::write_fragment(const Fragment& fragment) { // Open array for writing. @@ -1094,6 +1142,10 @@ static bool can_complete_in_memory_budget( // and take more memory const uint64_t coords_budget = std::stoi(instance.memory.total_budget_) * std::stod(instance.memory.ratio_coords_); + /* + * Iterate through the tiles in the same order that the sparse + * reader would process them in, tracking memory usage as we go. + */ uint64_t active_tile_size = sizeof(RT) * num_tiles; uint64_t next_tile_size = 0; while (active_tile_size + next_tile_size < coords_budget && @@ -1495,12 +1547,6 @@ TEST_CASE_METHOD( fragment_size, num_user_cells, subarray); }); } - - /** - * Now we should have 200 tiles, each of which has 2 coordinates, - * and each of which is size is 1584. - * In global order we skew towards fragment 1 which has lots of duplicates. - */ } /** @@ -2440,6 +2486,10 @@ TEST_CASE_METHOD( tiledb_query_free(&query); } +/** + * Creates an array with a schema whose dimensions and attributes + * come from `Instance`. + */ template void CSparseGlobalOrderFx::create_array(const Instance& instance) { tiledb_object_t type; @@ -2503,6 +2553,13 @@ void CSparseGlobalOrderFx::create_array(const Instance& instance) { instance.allow_duplicates()); } +/** + * Runs a correctness check upon `instance`. + * + * Inserts all of the fragments, then submits a global order read + * query and compares the results of the query against the + * expected result order computed from the input data. + */ template void CSparseGlobalOrderFx::run(Instance instance) { RCCATCH_REQUIRE(instance.num_user_cells > 0); @@ -2724,8 +2781,12 @@ void CSparseGlobalOrderFx::run(Instance instance) { } } +// rapidcheck generators and Arbitrary specializations namespace rc { +/** + * @return a generator of valid subarrays within `domain` + */ Gen>> make_subarray_1d( const tdbrc::Domain& domain) { // NB: when (if) multi-range subarray is supported for global order @@ -2789,6 +2850,9 @@ struct Arbitrary { } }; +/** + * @return a generator of valid subarrays within the domains `d1` and `d2` + */ Gen>, std::optional>>>> @@ -2861,6 +2925,9 @@ struct Arbitrary { } }; +/** + * Specializes `show` to print the final test case after shrinking + */ template <> void show(const FxRun1D& instance, std::ostream& os) { size_t f = 0; @@ -2907,6 +2974,9 @@ void show(const FxRun1D& instance, std::ostream& os) { os << "}"; } +/** + * Specializes `show` to print the final test case after shrinking + */ template <> void show(const FxRun2D& instance, std::ostream& os) { size_t f = 0; @@ -2968,6 +3038,16 @@ void show(const FxRun2D& instance, std::ostream& os) { } // namespace rc +/** + * Applies `::run` to completely arbitrary 1D input. + * + * `NonShrinking` is used because the shrink space is very large, + * and rapidcheck does not appear to give up. Hence if an instance + * fails, it will shrink for an arbitrarily long time, which is + * not appropriate for CI. If this happens, copy the seed and open a story, + * and whoever investigates can remove the `NonShrinking` part and let + * it run for... well who knows how long, really. + */ TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: rapidcheck 1d", @@ -2979,6 +3059,16 @@ TEST_CASE_METHOD( } } +/** + * Applies `::run` to completely arbitrary 2D input. + * + * `NonShrinking` is used because the shrink space is very large, + * and rapidcheck does not appear to give up. Hence if an instance + * fails, it will shrink for an arbitrarily long time, which is + * not appropriate for CI. If this happens, copy the seed and open a story, + * and whoever investigates can remove the `NonShrinking` part and let + * it run for... well who knows how long, really. + */ TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: rapidcheck 2d", @@ -3028,6 +3118,9 @@ TEST_CASE_METHOD( std::string::npos); } +/** + * Records durations as reported by `tiledb::sm::stats::DurationInstrument`. + */ struct TimeKeeper { std::map> durations; @@ -3041,6 +3134,9 @@ struct TimeKeeper { durations[stat].push_back(duration.count()); } + /** + * Write durations to a file for analysis. + */ void dump_durations(const char* path) const { std::ofstream dump(path); @@ -3063,8 +3159,14 @@ struct TimeKeeper { }; /** - * Runs sparse global order reader on a 2D array which is - * highly representative of SOMA workloads + * Runs sparse global order reader on a 2D array + * with two `int64_t` dimensions and a `float` attribute. + * This schema is common in SOMA, comparing the results + * from "preprocess merge off" and "preprocess merge on". + * + * The time of each `tiledb_query_submit` is recorded + * for both variations, and then dumped to `/tmp/time_keeper.out` + * when the test is completed. */ TEST_CASE_METHOD( CSparseGlobalOrderFx, From 109b223c6e448fa1fc1edc3802ce1d933adf1dd8 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 2 Jan 2025 20:51:24 -0500 Subject: [PATCH 100/228] std::integral T for Range constructor --- tiledb/type/range/range.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tiledb/type/range/range.h b/tiledb/type/range/range.h index 262dafc24ea..662a2290286 100644 --- a/tiledb/type/range/range.h +++ b/tiledb/type/range/range.h @@ -171,7 +171,7 @@ class Range { set_str_range(s1, s2); } - template + template Range(const T& start, const T& end, const allocator_type& alloc = {}) : Range( static_cast(&start), From 99dbbfc11ad453dc273003df40c4e88e6ac359eb Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 2 Jan 2025 20:54:25 -0500 Subject: [PATCH 101/228] Hidden tag for benchmark test --- test/src/unit-sparse-global-order-reader.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 3c54108057d..92bad369abd 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -3171,7 +3171,7 @@ struct TimeKeeper { TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: benchmark compare", - "[sparse-global-order]") { + "[sparse-global-order][.]") { using Asserter = tiledb::test::AsserterCatch; const char* array_uri = From 1cd4169d03819ed5512405fc2c7325cb224110ed Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 2 Jan 2025 21:15:47 -0500 Subject: [PATCH 102/228] Turn on by default --- tiledb/api/c_api/config/config_api_external.h | 2 +- tiledb/sm/config/config.cc | 2 +- tiledb/sm/cpp_api/config.h | 9 +++++++++ 3 files changed, 11 insertions(+), 2 deletions(-) diff --git a/tiledb/api/c_api/config/config_api_external.h b/tiledb/api/c_api/config/config_api_external.h index c74cbf6d45c..fbc0c9a4597 100644 --- a/tiledb/api/c_api/config/config_api_external.h +++ b/tiledb/api/c_api/config/config_api_external.h @@ -265,7 +265,7 @@ TILEDB_EXPORT void tiledb_config_free(tiledb_config_t** config) TILEDB_NOEXCEPT; * there are many fragments or when the distribution in space of the * tiles amongst the fragments is skewed. The value of the parameter * specifies the amount of work per parallel task. - * **Default**: "false" + * **Default**: "128" * - `sm.query.sparse_unordered_with_dups.reader`
* Which reader to use for sparse unordered with dups queries. * "refactored" or "legacy".
diff --git a/tiledb/sm/config/config.cc b/tiledb/sm/config/config.cc index 6a456527705..6579306dcc1 100644 --- a/tiledb/sm/config/config.cc +++ b/tiledb/sm/config/config.cc @@ -119,7 +119,7 @@ const std::string Config::SM_QUERY_DENSE_QC_COORDS_MODE = "false"; const std::string Config::SM_QUERY_DENSE_READER = "refactored"; const std::string Config::SM_QUERY_SPARSE_GLOBAL_ORDER_READER = "refactored"; const std::string Config::SM_QUERY_SPARSE_GLOBAL_ORDER_PREPROCESS_TILE_MERGE = - "0"; + "128"; const std::string Config::SM_QUERY_SPARSE_UNORDERED_WITH_DUPS_READER = "refactored"; const std::string Config::SM_MEM_MALLOC_TRIM = "true"; diff --git a/tiledb/sm/cpp_api/config.h b/tiledb/sm/cpp_api/config.h index 3d8bbc9afff..80ffb7c32c9 100644 --- a/tiledb/sm/cpp_api/config.h +++ b/tiledb/sm/cpp_api/config.h @@ -429,6 +429,15 @@ class Config { * Which reader to use for sparse global order queries. "refactored" * or "legacy".
* **Default**: refactored + * - `sm.query.sparse_global_order.preprocess_tile_merge`
+ * Performance configuration for sparse global order read queries. + * If nonzero, prior to loading the first tiles, the reader will run + * a preprocessing step to arrange tiles from all fragments in a single + * globally ordered list. This is expected to improve performance when + * there are many fragments or when the distribution in space of the + * tiles amongst the fragments is skewed. The value of the parameter + * specifies the amount of work per parallel task. + * **Default**: "128" * - `sm.query.sparse_unordered_with_dups.reader`
* Which reader to use for sparse unordered with dups queries. * "refactored" or "legacy".
From d9a93fc68819ead5f1343c3402b620df00bd1e5d Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 3 Jan 2025 08:46:18 -0500 Subject: [PATCH 103/228] Use default value directly in unit-capi-config.cc --- test/src/unit-capi-config.cc | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/test/src/unit-capi-config.cc b/test/src/unit-capi-config.cc index 02ec25d91d4..14eb227d6ed 100644 --- a/test/src/unit-capi-config.cc +++ b/test/src/unit-capi-config.cc @@ -32,6 +32,7 @@ #include #include "tiledb/sm/c_api/tiledb.h" +#include "tiledb/sm/config/config.h" #include #include @@ -41,6 +42,8 @@ #include #include +using tiledb::sm::Config; + void remove_file(const std::string& filename) { // Remove file tiledb_ctx_t* ctx = nullptr; @@ -292,7 +295,8 @@ void check_save_to_file() { ss << "sm.partial_tile_offsets_loading false\n"; ss << "sm.query.dense.qc_coords_mode false\n"; ss << "sm.query.dense.reader refactored\n"; - ss << "sm.query.sparse_global_order.preprocess_tile_merge 0\n"; + ss << "sm.query.sparse_global_order.preprocess_tile_merge " + << Config::SM_QUERY_SPARSE_GLOBAL_ORDER_PREPROCESS_TILE_MERGE << "\n"; ss << "sm.query.sparse_global_order.reader refactored\n"; ss << "sm.query.sparse_unordered_with_dups.reader refactored\n"; ss << "sm.read_range_oob warn\n"; @@ -642,7 +646,8 @@ TEST_CASE("C API: Test config iter", "[capi][config]") { all_param_values["sm.memory_budget_var"] = "10737418240"; all_param_values["sm.query.dense.qc_coords_mode"] = "false"; all_param_values["sm.query.dense.reader"] = "refactored"; - all_param_values["sm.query.sparse_global_order.preprocess_tile_merge"] = "0"; + all_param_values["sm.query.sparse_global_order.preprocess_tile_merge"] = + Config::SM_QUERY_SPARSE_GLOBAL_ORDER_PREPROCESS_TILE_MERGE; all_param_values["sm.query.sparse_global_order.reader"] = "refactored"; all_param_values["sm.query.sparse_unordered_with_dups.reader"] = "refactored"; all_param_values["sm.mem.consolidation.buffers_weight"] = "1"; From 781b87626c7d2f2e23a3ad785ab432ab5cbbad33 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 3 Jan 2025 09:43:26 -0500 Subject: [PATCH 104/228] Fix erroneous recomputation of tile order after completion --- .../readers/sparse_global_order_reader.cc | 8 +++- .../readers/sparse_global_order_reader.h | 3 +- .../query/readers/sparse_index_reader_base.cc | 3 +- .../query/readers/sparse_index_reader_base.h | 11 +++++- tiledb/sm/serialization/query.cc | 4 +- tiledb/sm/serialization/tiledb-rest.capnp | 1 + tiledb/sm/serialization/tiledb-rest.capnp.c++ | 38 +++++++++++++------ tiledb/sm/serialization/tiledb-rest.capnp.h | 21 +++++++++- 8 files changed, 70 insertions(+), 19 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 1ce614e5bee..af4deb672bd 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -156,6 +156,7 @@ SparseGlobalOrderReader::SparseGlobalOrderReader( "sm.query.sparse_global_order.preprocess_tile_merge") .value_or(0); preprocess_tile_order_.cursor_ = 0; + preprocess_tile_order_.num_tiles_ = 1; // will be adjusted later if needed if (!preprocess_tile_order_.enabled_) { all_fragment_tile_order_.memory_used_for_coords_.resize( @@ -198,11 +199,12 @@ void SparseGlobalOrderReader::refresh_config() { template void SparseGlobalOrderReader::set_preprocess_tile_order_cursor( - uint64_t cursor) { + uint64_t cursor, uint64_t num_tiles) { preprocess_tile_order_.enabled_ = true; preprocess_tile_order_.cursor_ = cursor; + preprocess_tile_order_.num_tiles_ = num_tiles; - // The tile order itself will be recomputed. + // The tile order itself will be recomputed if needed. // We get smaller messages but at a higher CPU cost. } @@ -237,6 +239,7 @@ Status SparseGlobalOrderReader::dowork() { // subarray) std::optional preprocess_future; if (preprocess_tile_order_.enabled_ && + preprocess_tile_order_.has_more_tiles() && preprocess_tile_order_.tiles_.empty()) { preprocess_future.emplace(memory_used_for_coords_total_); preprocess_compute_result_tile_order(preprocess_future.value()); @@ -573,6 +576,7 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( fragment_result_tile_spans.push_back(std::span(f)); } + preprocess_tile_order_.num_tiles_ = num_result_tiles; preprocess_tile_order_.tiles_.resize( num_result_tiles, ResultTileId{.fragment_idx_ = 0, .tile_idx_ = 0}); diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index dbf4895cf0d..d198a9d5edf 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -136,7 +136,8 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, std::string name(); /** Used in deserialization */ - virtual void set_preprocess_tile_order_cursor(uint64_t cursor) override; + virtual void set_preprocess_tile_order_cursor( + uint64_t cursor, uint64_t num_tiles) override; private: /* ********************************* */ diff --git a/tiledb/sm/query/readers/sparse_index_reader_base.cc b/tiledb/sm/query/readers/sparse_index_reader_base.cc index 40fed5a0184..68da67aaf33 100644 --- a/tiledb/sm/query/readers/sparse_index_reader_base.cc +++ b/tiledb/sm/query/readers/sparse_index_reader_base.cc @@ -141,7 +141,8 @@ const PreprocessTileOrder SparseIndexReaderBase::preprocess_tile_order() const { return preprocess_tile_order_; } -void SparseIndexReaderBase::set_preprocess_tile_order_cursor(uint64_t) { +void SparseIndexReaderBase::set_preprocess_tile_order_cursor( + uint64_t, uint64_t) { throw SparseIndexReaderBaseException( "Internal error: set_preprocess_tile_order_cursor for unsupported sparse " "index reader"); diff --git a/tiledb/sm/query/readers/sparse_index_reader_base.h b/tiledb/sm/query/readers/sparse_index_reader_base.h index 7a774ba175e..9be1617a835 100644 --- a/tiledb/sm/query/readers/sparse_index_reader_base.h +++ b/tiledb/sm/query/readers/sparse_index_reader_base.h @@ -303,8 +303,14 @@ struct PreprocessTileOrder { size_t cursor_; std::vector tiles_; + // NB: looks redundant with tiles_.size() but + // we need to mark completeness without using tiles_ because: + // 1) for REST tiles_ is not serialized + // 2) tiles_ is cleared to release memory once it is done + size_t num_tiles_; + bool has_more_tiles() const { - return cursor_ < tiles_.size(); + return cursor_ < num_tiles_; } }; @@ -622,7 +628,8 @@ class SparseIndexReaderBase : public ReaderBase { * * @param cursor New cursor value. */ - virtual void set_preprocess_tile_order_cursor(uint64_t cursor); + virtual void set_preprocess_tile_order_cursor( + uint64_t cursor, uint64_t num_tiles); protected: /* ********************************* */ diff --git a/tiledb/sm/serialization/query.cc b/tiledb/sm/serialization/query.cc index 6f37120d901..4bd6904b7fc 100644 --- a/tiledb/sm/serialization/query.cc +++ b/tiledb/sm/serialization/query.cc @@ -937,6 +937,7 @@ Status index_reader_to_capnp( if (reader.preprocess_tile_order().enabled_) { auto preprocess = reader_builder->initPreprocess(); preprocess.setCursor(reader.preprocess_tile_order().cursor_); + preprocess.setNumTiles(reader.preprocess_tile_order().num_tiles_); } return Status::Ok(); @@ -1174,7 +1175,8 @@ Status index_reader_from_capnp( if (reader_reader.hasPreprocess()) { reader->set_preprocess_tile_order_cursor( - reader_reader.getPreprocess().getCursor()); + reader_reader.getPreprocess().getCursor(), + reader_reader.getPreprocess().getNumTiles()); } return Status::Ok(); diff --git a/tiledb/sm/serialization/tiledb-rest.capnp b/tiledb/sm/serialization/tiledb-rest.capnp index e8083d01e79..a0448dd0c62 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp +++ b/tiledb/sm/serialization/tiledb-rest.capnp @@ -709,6 +709,7 @@ struct ReadStateIndex { struct PreprocessTileOrder { cursor @0 :UInt64; + numTiles @1 :UInt64; } struct ReaderIndex { diff --git a/tiledb/sm/serialization/tiledb-rest.capnp.c++ b/tiledb/sm/serialization/tiledb-rest.capnp.c++ index d7a41345c17..7be151d3bc5 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp.c++ +++ b/tiledb/sm/serialization/tiledb-rest.capnp.c++ @@ -5462,17 +5462,17 @@ const ::capnp::_::RawSchema s_c86c77b5f6a2bf0f = { 2, 3, i_c86c77b5f6a2bf0f, nullptr, nullptr, { &s_c86c77b5f6a2bf0f, nullptr, nullptr, 0, 0, nullptr }, false }; #endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<34> b_818a8600b3452aa4 = { +static const ::capnp::_::AlignedData<50> b_818a8600b3452aa4 = { { 0, 0, 0, 0, 5, 0, 6, 0, 164, 42, 69, 179, 0, 134, 138, 129, - 18, 0, 0, 0, 1, 0, 1, 0, + 18, 0, 0, 0, 1, 0, 2, 0, 127, 216, 135, 181, 36, 146, 125, 181, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 0, 50, 1, 0, 0, 37, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 33, 0, 0, 0, 63, 0, 0, 0, + 33, 0, 0, 0, 119, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 116, 105, 108, 101, 100, 98, 45, 114, @@ -5481,15 +5481,31 @@ static const ::capnp::_::AlignedData<34> b_818a8600b3452aa4 = { 99, 101, 115, 115, 84, 105, 108, 101, 79, 114, 100, 101, 114, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, - 4, 0, 0, 0, 3, 0, 4, 0, + 8, 0, 0, 0, 3, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 13, 0, 0, 0, 58, 0, 0, 0, + 41, 0, 0, 0, 58, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 8, 0, 0, 0, 3, 0, 1, 0, - 20, 0, 0, 0, 2, 0, 1, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 44, 0, 0, 0, 3, 0, 1, 0, + 56, 0, 0, 0, 2, 0, 1, 0, 99, 117, 114, 115, 111, 114, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 117, 109, 84, 105, 108, 101, 115, + 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5500,11 +5516,11 @@ static const ::capnp::_::AlignedData<34> b_818a8600b3452aa4 = { }; ::capnp::word const* const bp_818a8600b3452aa4 = b_818a8600b3452aa4.words; #if !CAPNP_LITE -static const uint16_t m_818a8600b3452aa4[] = {0}; -static const uint16_t i_818a8600b3452aa4[] = {0}; +static const uint16_t m_818a8600b3452aa4[] = {0, 1}; +static const uint16_t i_818a8600b3452aa4[] = {0, 1}; const ::capnp::_::RawSchema s_818a8600b3452aa4 = { - 0x818a8600b3452aa4, b_818a8600b3452aa4.words, 34, nullptr, m_818a8600b3452aa4, - 0, 1, i_818a8600b3452aa4, nullptr, nullptr, { &s_818a8600b3452aa4, nullptr, nullptr, 0, 0, nullptr }, false + 0x818a8600b3452aa4, b_818a8600b3452aa4.words, 50, nullptr, m_818a8600b3452aa4, + 0, 2, i_818a8600b3452aa4, nullptr, nullptr, { &s_818a8600b3452aa4, nullptr, nullptr, 0, 0, nullptr }, false }; #endif // !CAPNP_LITE static const ::capnp::_::AlignedData<112> b_9b9a5fc7713a8692 = { diff --git a/tiledb/sm/serialization/tiledb-rest.capnp.h b/tiledb/sm/serialization/tiledb-rest.capnp.h index d198f47750a..bf7e500e676 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp.h +++ b/tiledb/sm/serialization/tiledb-rest.capnp.h @@ -1039,7 +1039,7 @@ struct PreprocessTileOrder { class Pipeline; struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(818a8600b3452aa4, 1, 0) + CAPNP_DECLARE_STRUCT_HEADER(818a8600b3452aa4, 2, 0) #if !CAPNP_LITE static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; @@ -9198,6 +9198,8 @@ class PreprocessTileOrder::Reader { inline ::uint64_t getCursor() const; + inline ::uint64_t getNumTiles() const; + private: ::capnp::_::StructReader _reader; template @@ -9240,6 +9242,9 @@ class PreprocessTileOrder::Builder { inline ::uint64_t getCursor(); inline void setCursor(::uint64_t value); + inline ::uint64_t getNumTiles(); + inline void setNumTiles(::uint64_t value); + private: ::capnp::_::StructBuilder _builder; template @@ -25792,6 +25797,20 @@ inline void PreprocessTileOrder::Builder::setCursor(::uint64_t value) { ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } +inline ::uint64_t PreprocessTileOrder::Reader::getNumTiles() const { + return _reader.getDataField<::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t PreprocessTileOrder::Builder::getNumTiles() { + return _builder.getDataField<::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void PreprocessTileOrder::Builder::setNumTiles(::uint64_t value) { + _builder.setDataField<::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + inline bool ReaderIndex::Reader::hasLayout() const { return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) .isNull(); From 76d80a3cb87b2d585bb861078aa4188de4514190 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 3 Jan 2025 09:50:09 -0500 Subject: [PATCH 105/228] Move tuple.h to stdx directory --- test/support/rapidcheck/array.h | 2 +- test/support/{ => stdx}/tuple.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) rename test/support/{ => stdx}/tuple.h (99%) diff --git a/test/support/rapidcheck/array.h b/test/support/rapidcheck/array.h index 585e465bb90..a89789fe759 100644 --- a/test/support/rapidcheck/array.h +++ b/test/support/rapidcheck/array.h @@ -38,8 +38,8 @@ #include "tiledb/type/datatype_traits.h" #include "tiledb/type/range/range.h" +#include #include -#include #include #include diff --git a/test/support/tuple.h b/test/support/stdx/tuple.h similarity index 99% rename from test/support/tuple.h rename to test/support/stdx/tuple.h index d6336959c89..4c781597abf 100644 --- a/test/support/tuple.h +++ b/test/support/stdx/tuple.h @@ -1,5 +1,5 @@ /** - * @file test/support/tuple.h + * @file test/support/stdx/tuple.h * * @section LICENSE * From d3253d87321200bd995ead333d56e194ae7c117a Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 3 Jan 2025 10:13:07 -0500 Subject: [PATCH 106/228] Split up rapidcheck/array.h file and change namespace --- test/src/unit-sparse-global-order-reader.cc | 135 +++++----- .../rapidcheck/{array.h => array_templates.h} | 223 +--------------- test/support/src/array_templates.h | 250 ++++++++++++++++++ test/support/tdb_rapidcheck.h | 14 +- 4 files changed, 330 insertions(+), 292 deletions(-) rename test/support/rapidcheck/{array.h => array_templates.h} (54%) create mode 100644 test/support/src/array_templates.h diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 92bad369abd..53414657634 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -30,7 +30,8 @@ * Tests for the sparse global order reader. */ -#include "test/support/rapidcheck/array.h" +#include "test/support/rapidcheck/array_templates.h" +#include "test/support/src/array_templates.h" #include "test/support/src/error_helpers.h" #include "test/support/src/helpers.h" #include "test/support/src/vfs_helpers.h" @@ -61,14 +62,13 @@ using namespace tiledb; using namespace tiledb::test; using tiledb::sm::Datatype; -using tiledb::test::tdbrc::AttributeType; -using tiledb::test::tdbrc::DimensionType; -using tiledb::test::tdbrc::FragmentType; -using tiledb::test::tdbrc::NonShrinking; +using tiledb::test::templates::AttributeType; +using tiledb::test::templates::DimensionType; +using tiledb::test::templates::FragmentType; namespace rc { -Gen>> make_subarray_1d( - const tdbrc::Domain& domain); +Gen>> make_subarray_1d( + const templates::Domain& domain); } /* ********************************* */ @@ -100,7 +100,7 @@ struct DefaultArray1DConfig { uint64_t capacity; bool allow_dups; - tdbrc::Dimension dimension; + templates::Dimension dimension; DefaultArray1DConfig() : capacity(2) @@ -121,14 +121,14 @@ struct DefaultArray1DConfig { * An instance of one-dimension array input to `CSparseGlobalOrderFx::run` */ struct FxRun1D { - using FragmentType = tdbrc::Fragment1D; + using FragmentType = templates::Fragment1D; uint64_t num_user_cells; std::vector fragments; // NB: for now this always has length 1, global order query does not // support multi-range subarray - std::vector> subarray; + std::vector> subarray; DefaultArray1DConfig array; MemoryBudget memory; @@ -177,7 +177,7 @@ struct FxRun1D { bool intersects(const sm::NDRange& mbr) const { auto accept = [&](const auto& range) { const auto& untyped_mbr = mbr[0]; - const tdbrc::Domain typed_mbr( + const templates::Domain typed_mbr( untyped_mbr.start_as(), untyped_mbr.end_as()); return range.intersects(typed_mbr); }; @@ -203,8 +203,8 @@ struct FxRun1D { } } - std::tuple&> dimensions() const { - return std::tuple&>( + std::tuple&> dimensions() const { + return std::tuple&>( array.dimension); } @@ -216,20 +216,20 @@ struct FxRun1D { struct FxRun2D { using Coord0Type = int; using Coord1Type = int; - using FragmentType = tdbrc::Fragment2D; + using FragmentType = templates::Fragment2D; std::vector fragments; std::vector>, - std::optional>>> + std::optional>, + std::optional>>> subarray; size_t num_user_cells; uint64_t capacity; bool allow_dups; - tdbrc::Dimension d1; - tdbrc::Dimension d2; + templates::Dimension d1; + templates::Dimension d2; MemoryBudget memory; @@ -237,9 +237,9 @@ struct FxRun2D { : num_user_cells(8) , capacity(64) , allow_dups(true) { - d1.domain = tdbrc::Domain(1, 200); + d1.domain = templates::Domain(1, 200); d1.extent = 8; - d2.domain = tdbrc::Domain(1, 200); + d2.domain = templates::Domain(1, 200); d2.extent = 8; } @@ -325,9 +325,9 @@ struct FxRun2D { return true; } - const tdbrc::Domain typed_domain0( + const templates::Domain typed_domain0( mbr[0].start_as(), mbr[0].end_as()); - const tdbrc::Domain typed_domain1( + const templates::Domain typed_domain1( mbr[1].start_as(), mbr[1].end_as()); for (const auto& range : subarray) { @@ -364,8 +364,8 @@ struct FxRun2D { } using CoordsRefType = std::tuple< - const tdbrc::Dimension&, - const tdbrc::Dimension&>; + const templates::Dimension&, + const templates::Dimension&>; CoordsRefType dimensions() const { return CoordsRefType(d1, d2); } @@ -1420,16 +1420,16 @@ TEST_CASE_METHOD( size_t fragment_size, size_t num_user_cells, int extent, - const std::vector>& subarray = - std::vector>()) { + const std::vector>& subarray = + std::vector>()) { // Write a fragment F0 with unique coordinates - tdbrc::Fragment1D fragment0; + templates::Fragment1D fragment0; fragment0.dim_.resize(fragment_size); std::iota(fragment0.dim_.begin(), fragment0.dim_.end(), 1); // Write a fragment F1 with lots of duplicates // [100,100,100,100,100,101,101,101,101,101,102,102,102,102,102,...] - tdbrc::Fragment1D fragment1; + templates::Fragment1D fragment1; fragment1.dim_.resize(fragment0.dim_.size()); for (size_t i = 0; i < fragment1.dim_.size(); i++) { fragment1.dim_[i] = @@ -1470,7 +1470,8 @@ TEST_CASE_METHOD( const size_t fragment_size = *rc::gen::inRange(2, 200); const size_t num_user_cells = *rc::gen::inRange(1, 1024); const int extent = *rc::gen::inRange(1, 200); - const auto subarray = *rc::make_subarray_1d(tdbrc::Domain(1, 200)); + const auto subarray = + *rc::make_subarray_1d(templates::Domain(1, 200)); doit.operator()( fragment_size, num_user_cells, extent, subarray); }); @@ -1496,9 +1497,9 @@ TEST_CASE_METHOD( auto doit = [this]( size_t fragment_size, size_t num_user_cells, - const std::vector>& subarray = {}) { - tdbrc::Fragment1D fragment0; - tdbrc::Fragment1D fragment1; + const std::vector>& subarray = {}) { + templates::Fragment1D fragment0; + templates::Fragment1D fragment1; // Write a fragment F0 with tiles [1,3][3,5][5,7][7,9]... fragment0.dim_.resize(fragment_size); @@ -1542,7 +1543,8 @@ TEST_CASE_METHOD( rc::prop("rapidcheck fragment interleave", [doit]() { const size_t fragment_size = *rc::gen::inRange(2, 196); const size_t num_user_cells = *rc::gen::inRange(1, 1024); - const auto subarray = *rc::make_subarray_1d(tdbrc::Domain(1, 200)); + const auto subarray = + *rc::make_subarray_1d(templates::Domain(1, 200)); doit.operator()( fragment_size, num_user_cells, subarray); }); @@ -1585,8 +1587,8 @@ TEST_CASE_METHOD( size_t num_fragments, size_t fragment_size, size_t num_user_cells, - const std::vector>& subarray = - std::vector>()) { + const std::vector>& subarray = + std::vector>()) { const uint64_t total_budget = 100000; const double ratio_coords = 0.2; @@ -1601,7 +1603,7 @@ TEST_CASE_METHOD( instance.memory.ratio_array_data_ = "0.6"; for (size_t f = 0; f < num_fragments; f++) { - tdbrc::Fragment1D fragment; + templates::Fragment1D fragment; fragment.dim_.resize(fragment_size); std::iota( fragment.dim_.begin(), @@ -1630,7 +1632,8 @@ TEST_CASE_METHOD( const size_t fragment_size = *rc::gen::inRange(2, 200 - 64); // const size_t num_user_cells = *rc::gen::inRange(1, 1024 * 1024); const size_t num_user_cells = 1024; - const auto subarray = *rc::make_subarray_1d(tdbrc::Domain(1, 200)); + const auto subarray = + *rc::make_subarray_1d(templates::Domain(1, 200)); doit.operator()( num_fragments, fragment_size, num_user_cells, subarray); }); @@ -2507,8 +2510,9 @@ void CSparseGlobalOrderFx::create_array(const Instance& instance) { std::vector dimension_types; std::vector dimension_ranges; std::vector dimension_extents; - auto add_dimension = [&](const tdbrc::Dimension& dimension) { - using CoordType = tdbrc::Dimension::value_type; + auto add_dimension = [&]( + const templates::Dimension& dimension) { + using CoordType = templates::Dimension::value_type; dimension_names.push_back("d" + std::to_string(dimension_names.size() + 1)); dimension_types.push_back(static_cast(D)); dimension_ranges.push_back( @@ -2516,7 +2520,7 @@ void CSparseGlobalOrderFx::create_array(const Instance& instance) { dimension_extents.push_back(const_cast(&dimension.extent)); }; std::apply( - [&](const tdbrc::Dimension&... dimension) { + [&](const templates::Dimension&... dimension) { (add_dimension(dimension), ...); }, dimensions); @@ -2618,8 +2622,8 @@ void CSparseGlobalOrderFx::run(Instance instance) { const auto l = std::make_tuple(dims[ia]...); const auto r = std::make_tuple(dims[ib]...); return globalcmp( - tdbrc::global_cell_cmp_std_tuple(l), - tdbrc::global_cell_cmp_std_tuple(r)); + templates::global_cell_cmp_std_tuple(l), + templates::global_cell_cmp_std_tuple(r)); }, expect.dimensions()); }); @@ -2787,8 +2791,8 @@ namespace rc { /** * @return a generator of valid subarrays within `domain` */ -Gen>> make_subarray_1d( - const tdbrc::Domain& domain) { +Gen>> make_subarray_1d( + const templates::Domain& domain) { // NB: when (if) multi-range subarray is supported for global order // (or if this is used for non-global order) // change `num_ranges` to use the weighted element version @@ -2801,7 +2805,7 @@ Gen>> make_subarray_1d( } return gen::mapcat(*num_ranges, [domain](int num_ranges) { - return gen::container>>( + return gen::container>>( num_ranges, rc::make_range(domain)); }); } @@ -2812,10 +2816,10 @@ struct Arbitrary { constexpr Datatype DimensionType = Datatype::INT32; using CoordType = tiledb::type::datatype_traits::value_type; - auto dimension = gen::arbitrary>(); + auto dimension = gen::arbitrary>(); - auto fragments = - gen::mapcat(dimension, [](tdbrc::Dimension dimension) { + auto fragments = gen::mapcat( + dimension, [](templates::Dimension dimension) { auto fragment = rc::make_fragment_1d(dimension.domain); @@ -2823,7 +2827,7 @@ struct Arbitrary { gen::just(dimension), make_subarray_1d(dimension.domain), gen::nonEmpty( - gen::container>>( + gen::container>>( fragment))); }); @@ -2831,9 +2835,9 @@ struct Arbitrary { return gen::apply( [](std::tuple< - tdbrc::Dimension, - std::vector>, - std::vector>> fragments, + templates::Dimension, + std::vector>, + std::vector>> fragments, int num_user_cells) { FxRun1D instance; std::tie( @@ -2854,9 +2858,10 @@ struct Arbitrary { * @return a generator of valid subarrays within the domains `d1` and `d2` */ Gen>, - std::optional>>>> -make_subarray_2d(const tdbrc::Domain& d1, const tdbrc::Domain& d2) { + std::optional>, + std::optional>>>> +make_subarray_2d( + const templates::Domain& d1, const templates::Domain& d2) { // NB: multi-range subarray is not supported (yet?) for global order read return gen::apply( @@ -2891,8 +2896,8 @@ struct Arbitrary { tiledb::type::datatype_traits::value_type, Coord1Type>); - auto d0 = gen::arbitrary>(); - auto d1 = gen::arbitrary>(); + auto d0 = gen::arbitrary>(); + auto d1 = gen::arbitrary>(); auto fragments = gen::mapcat(gen::pair(d0, d1), [](auto dimensions) { auto fragment = rc::make_fragment_2d( @@ -3053,9 +3058,10 @@ TEST_CASE_METHOD( "Sparse global order reader: rapidcheck 1d", "[sparse-global-order][rapidcheck]") { SECTION("Rapidcheck") { - rc::prop("rapidcheck arbitrary 1d", [this](NonShrinking instance) { - run(instance); - }); + rc::prop( + "rapidcheck arbitrary 1d", [this](rc::NonShrinking instance) { + run(instance); + }); } } @@ -3074,9 +3080,10 @@ TEST_CASE_METHOD( "Sparse global order reader: rapidcheck 2d", "[sparse-global-order][rapidcheck]") { SECTION("rapidcheck") { - rc::prop("rapidcheck arbitrary 2d", [this](NonShrinking instance) { - run(instance); - }); + rc::prop( + "rapidcheck arbitrary 2d", [this](rc::NonShrinking instance) { + run(instance); + }); } } @@ -3090,7 +3097,7 @@ TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: multi-range subarray signal", "[sparse-global-order]") { - tdbrc::Fragment1D fragment0; + templates::Fragment1D fragment0; fragment0.dim_.push_back(1); std::get<0>(fragment0.atts_).push_back(1); diff --git a/test/support/rapidcheck/array.h b/test/support/rapidcheck/array_templates.h similarity index 54% rename from test/support/rapidcheck/array.h rename to test/support/rapidcheck/array_templates.h index a89789fe759..2eee43a251b 100644 --- a/test/support/rapidcheck/array.h +++ b/test/support/rapidcheck/array_templates.h @@ -1,5 +1,5 @@ /** - * @file test/support/rapidcheck/array.h + * @file test/support/rapidcheck/array_templates.h * * @section LICENSE * @@ -27,233 +27,20 @@ * * @section DESCRIPTION * - * This file defines structures and rapidcheck generators which - * can be commonly useful for writing rapidcheck properties - * about tiledb array. + * This file defines rapidcheck generators for the structures + * defined in test/support/src/array_templates.h. */ #ifndef TILEDB_RAPIDCHECK_ARRAY_H #define TILEDB_RAPIDCHECK_ARRAY_H -#include "tiledb/type/datatype_traits.h" -#include "tiledb/type/range/range.h" - +#include #include #include -#include -#include -#include -#include - -namespace tiledb::sm { -class Dimension; -} - -namespace tiledb::test::tdbrc { - -/** - * Adapts a `std::tuple` whose fields are all `GlobalCellCmp` - * to itself be `GlobalCellCmp`. - */ -template -struct global_cell_cmp_std_tuple { - global_cell_cmp_std_tuple(const StdTuple& tup) - : tup_(tup) { - } - - tiledb::common::UntypedDatumView dimension_datum( - const tiledb::sm::Dimension&, unsigned dim_idx) const { - return std::apply( - [&](const auto&... field) { - size_t sizes[] = {sizeof(std::decay_t)...}; - const void* const ptrs[] = { - static_cast(std::addressof(field))...}; - return UntypedDatumView(ptrs[dim_idx], sizes[dim_idx]); - }, - tup_); - } - - const void* coord(unsigned dim) const { - return std::apply( - [&](const auto&... field) { - const void* const ptrs[] = { - static_cast(std::addressof(field))...}; - return ptrs[dim]; - }, - tup_); - } - - const StdTuple& tup_; -}; - -/** - * Describes types which can be used for rapidcheck-generated dimensions. - */ -template -concept DimensionType = requires(const D& coord) { - typename ::rc::Arbitrary; - typename std::is_signed; - { coord < coord } -> std::same_as; - { D(int64_t(coord)) } -> std::same_as; -}; - -/** - * Describes types which can be used for rapidcheck-generated attributes. - */ -template -concept AttributeType = - requires(const T& coord) { typename ::rc::Arbitrary; }; - -/** - * Describes types which can be used as columnar data fragment input. - * - * Methods `dimensions` and `attributes` return tuples whose fields are each - * `std::vector` and `std::vector` - * respectively. - */ -template -concept FragmentType = requires(const T& fragment) { - { fragment.size() } -> std::convertible_to; - - // not sure how to specify "returns any tuple whose elements decay to - // std::vector" - fragment.dimensions(); - fragment.attributes(); -} and requires(T& fragment) { - // non-const versions - fragment.dimensions(); - fragment.attributes(); -}; - -/** - * A generic, statically-typed range which is inclusive on both ends. - */ -template -struct Domain { - D lower_bound; - D upper_bound; - - Domain() { - } - - Domain(D d1, D d2) - : lower_bound(std::min(d1, d2)) - , upper_bound(std::max(d1, d2)) { - } - - bool contains(D point) const { - return lower_bound <= point && point <= upper_bound; - } - - bool intersects(const Domain& other) const { - return (other.lower_bound <= lower_bound && - lower_bound <= other.upper_bound) || - (other.lower_bound <= upper_bound && - upper_bound <= other.upper_bound) || - (lower_bound <= other.lower_bound && - other.lower_bound <= upper_bound) || - (lower_bound <= other.upper_bound && - other.upper_bound <= upper_bound); - } - - tiledb::type::Range range() const { - return tiledb::type::Range(lower_bound, upper_bound); - } -}; - -/** - * A description of a dimension as it pertains to its datatype. - */ -template -struct Dimension { - using value_type = tiledb::type::datatype_traits::value_type; - - Domain domain; - value_type extent; -}; - -/** - * Data for a one-dimensional array - */ -template -struct Fragment1D { - std::vector dim_; - std::tuple...> atts_; - - uint64_t size() const { - return dim_.size(); - } - - std::tuple&> dimensions() const { - return std::tuple&>(dim_); - } - - std::tuple&...> attributes() const { - return std::apply( - [](const std::vector&... attribute) { - return std::tuple&...>(attribute...); - }, - atts_); - } - - std::tuple&> dimensions() { - return std::tuple&>(dim_); - } - - std::tuple&...> attributes() { - return std::apply( - [](std::vector&... attribute) { - return std::tuple&...>(attribute...); - }, - atts_); - } -}; - -/** - * Data for a two-dimensional array - */ -template -struct Fragment2D { - std::vector d1_; - std::vector d2_; - std::tuple...> atts_; - - uint64_t size() const { - return d1_.size(); - } - - std::tuple&, const std::vector&> dimensions() - const { - return std::tuple&, const std::vector&>(d1_, d2_); - } - - std::tuple&, std::vector&> dimensions() { - return std::tuple&, std::vector&>(d1_, d2_); - } - - std::tuple&...> attributes() const { - return std::apply( - [](const std::vector&... attribute) { - return std::tuple&...>(attribute...); - }, - atts_); - } - - std::tuple&...> attributes() { - return std::apply( - [](std::vector&... attribute) { - return std::tuple&...>(attribute...); - }, - atts_); - } -}; - -} // namespace tiledb::test::tdbrc - namespace rc { -using namespace tiledb::test::tdbrc; +using namespace tiledb::test::templates; template struct Arbitrary> { diff --git a/test/support/src/array_templates.h b/test/support/src/array_templates.h new file mode 100644 index 00000000000..17f4f1590d5 --- /dev/null +++ b/test/support/src/array_templates.h @@ -0,0 +1,250 @@ +/** + * @file test/support/src/array_templates.h + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2022-2024 TileDB, 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. + * + * @section DESCRIPTION + * + * This file provides templates for generic programming with respect + * to array schema, data types, etc. + */ + +#ifndef TILEDB_ARRAY_TEMPLATES_H +#define TILEDB_ARRAY_TEMPLATES_H + +#include "tiledb/type/datatype_traits.h" +#include "tiledb/type/range/range.h" + +#include +#include +#include + +namespace tiledb::sm { +class Dimension; +} + +namespace tiledb::test::templates { + +/** + * Adapts a `std::tuple` whose fields are all `GlobalCellCmp` + * to itself be `GlobalCellCmp`. + */ +template +struct global_cell_cmp_std_tuple { + global_cell_cmp_std_tuple(const StdTuple& tup) + : tup_(tup) { + } + + tiledb::common::UntypedDatumView dimension_datum( + const tiledb::sm::Dimension&, unsigned dim_idx) const { + return std::apply( + [&](const auto&... field) { + size_t sizes[] = {sizeof(std::decay_t)...}; + const void* const ptrs[] = { + static_cast(std::addressof(field))...}; + return UntypedDatumView(ptrs[dim_idx], sizes[dim_idx]); + }, + tup_); + } + + const void* coord(unsigned dim) const { + return std::apply( + [&](const auto&... field) { + const void* const ptrs[] = { + static_cast(std::addressof(field))...}; + return ptrs[dim]; + }, + tup_); + } + + const StdTuple& tup_; +}; + +/** + * Constrains types which can be used as the physical type of a dimension. + */ +template +concept DimensionType = requires(const D& coord) { + typename std::is_signed; + { coord < coord } -> std::same_as; + { D(int64_t(coord)) } -> std::same_as; +}; + +/** + * Constrains types which can be used as the physical type of an attribute. + * + * Right now this doesn't constrain anything, it is just a marker for + * readability, and someday we might want it do require something. + */ +template +concept AttributeType = true; + +/** + * Constrains types which can be used as columnar data fragment input. + * + * Methods `dimensions` and `attributes` return tuples whose fields are each + * `std::vector` and `std::vector` + * respectively. + */ +template +concept FragmentType = requires(const T& fragment) { + { fragment.size() } -> std::convertible_to; + + // not sure how to specify "returns any tuple whose elements decay to + // std::vector" + fragment.dimensions(); + fragment.attributes(); +} and requires(T& fragment) { + // non-const versions + fragment.dimensions(); + fragment.attributes(); +}; + +/** + * A generic, statically-typed range which is inclusive on both ends. + */ +template +struct Domain { + D lower_bound; + D upper_bound; + + Domain() { + } + + Domain(D d1, D d2) + : lower_bound(std::min(d1, d2)) + , upper_bound(std::max(d1, d2)) { + } + + bool contains(D point) const { + return lower_bound <= point && point <= upper_bound; + } + + bool intersects(const Domain& other) const { + return (other.lower_bound <= lower_bound && + lower_bound <= other.upper_bound) || + (other.lower_bound <= upper_bound && + upper_bound <= other.upper_bound) || + (lower_bound <= other.lower_bound && + other.lower_bound <= upper_bound) || + (lower_bound <= other.upper_bound && + other.upper_bound <= upper_bound); + } + + tiledb::type::Range range() const { + return tiledb::type::Range(lower_bound, upper_bound); + } +}; + +/** + * A description of a dimension as it pertains to its datatype. + */ +template +struct Dimension { + using value_type = tiledb::type::datatype_traits::value_type; + + Domain domain; + value_type extent; +}; + +/** + * Data for a one-dimensional array + */ +template +struct Fragment1D { + std::vector dim_; + std::tuple...> atts_; + + uint64_t size() const { + return dim_.size(); + } + + std::tuple&> dimensions() const { + return std::tuple&>(dim_); + } + + std::tuple&...> attributes() const { + return std::apply( + [](const std::vector&... attribute) { + return std::tuple&...>(attribute...); + }, + atts_); + } + + std::tuple&> dimensions() { + return std::tuple&>(dim_); + } + + std::tuple&...> attributes() { + return std::apply( + [](std::vector&... attribute) { + return std::tuple&...>(attribute...); + }, + atts_); + } +}; + +/** + * Data for a two-dimensional array + */ +template +struct Fragment2D { + std::vector d1_; + std::vector d2_; + std::tuple...> atts_; + + uint64_t size() const { + return d1_.size(); + } + + std::tuple&, const std::vector&> dimensions() + const { + return std::tuple&, const std::vector&>(d1_, d2_); + } + + std::tuple&, std::vector&> dimensions() { + return std::tuple&, std::vector&>(d1_, d2_); + } + + std::tuple&...> attributes() const { + return std::apply( + [](const std::vector&... attribute) { + return std::tuple&...>(attribute...); + }, + atts_); + } + + std::tuple&...> attributes() { + return std::apply( + [](std::vector&... attribute) { + return std::tuple&...>(attribute...); + }, + atts_); + } +}; + +} // namespace tiledb::test::templates + +#endif diff --git a/test/support/tdb_rapidcheck.h b/test/support/tdb_rapidcheck.h index 81d39e74a9f..a040c02f827 100644 --- a/test/support/tdb_rapidcheck.h +++ b/test/support/tdb_rapidcheck.h @@ -122,7 +122,7 @@ struct AsserterRapidcheck {}; } \ } while (0) -namespace tiledb::test::tdbrc { +namespace rc { /** * Wrapper struct whose `Arbitrary` specialization returns @@ -151,18 +151,12 @@ struct NonShrinking { } }; -} // namespace tiledb::test::tdbrc - -namespace rc { template -struct Arbitrary> { - static Gen> arbitrary() { +struct Arbitrary> { + static Gen> arbitrary() { auto inner = gen::noShrink(gen::arbitrary()); return gen::apply( - [](T inner) { - return tiledb::test::tdbrc::NonShrinking(std::move(inner)); - }, - inner); + [](T inner) { return NonShrinking(std::move(inner)); }, inner); } }; } // namespace rc From de3724559ffe962a7bc9cde572b2fb892ba859af Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 3 Jan 2025 10:50:26 -0500 Subject: [PATCH 107/228] Comment explains parallel merge algorithm, and simplify split_point_stream_bounds --- tiledb/common/algorithm/parallel_merge.h | 116 +++++++++++++++++++---- 1 file changed, 100 insertions(+), 16 deletions(-) diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h index 69edb4ad2bf..fc74555c6f2 100644 --- a/tiledb/common/algorithm/parallel_merge.h +++ b/tiledb/common/algorithm/parallel_merge.h @@ -28,9 +28,64 @@ * @section DESCRIPTION * * This file defines an implementation of a parallel merge algorithm for - * in-memory data. + * in-memory data. A merge combines the data from one or more sorted streams + * and produces a single sorted stream. * - * TODO: explain algorithm + * Let `K` be the number of input buffers, and `P` be the available parallelism. + * + * A K-way tournament merge does not present obvious parallelization + * opportunities. Each level of the tournament waits for its inputs to finish + * before yielding its own winner. Even if the only single-threaded critical + * path is the final level, each level feeding in can only leverage half of the + * available tasks relative to its input. And then each task is small: a single + * comparison. + * + * Another choice is to have a critical path as the *first* phase of the merge + * algorithm. Instead of parallelizing one merge, we can identify P + * non-overlapping merges from the input, and run each of the P merges fully in + * parallel. This is feasible if we can buffer a large enough amount of data + * from each stream. + * + * This implementation chooses the latter. + * + * The parallel merge algorithm runs in two phases: + * 1) identify merge units + * 2) run tournament merges + * + * We define a "merge unit" to be a set of bounds on each stream [L_k, U_k] + * such that all tuples inside the unit will occur contiguously in the output + * stream. Because the tuples inside the unit all occur contiguously, a merge + * unit can run and produce output without coordinating with other merge units. + * + * The "Identify Merge Units" phase is the sequential critical path. + * Given a total input size of N, we want to identify P merge units which each + * have approximately N/P tuples. We do this by reduction to + * "find a merge unit with N tuples which starts at position 0 in each input". + * Then, merge unit p is the difference between the bounds from that algorithm + * on (p * N/P) and ((p + 1) * N/P). + * + * How do we find a merge unit with N tuples which starts at position 0 in each + * input? Choose the "split point" as the midpoint of a stream k. Count the + * number of tuples in M each stream which are less than the split point. If M + * == N, then we can infer bounds on each stream and are done. If M < N, then + * we accumulate the bounds from each stream, advance the split point to stream + * k + 1, and try again with N - M tuples. And if M > N, then we shrink the + * views on each stream and try again using stream k + 1 for the new split + * point. + * + * One nice feature of this reduction is that we can "yield" merge units as we + * identify them, and simultaneously spawn the tasks to run the tournament merge + * as well as identify the next merge unit. + * + * The "Run Tournament Merges" phases proceeds in one parallel task for each of + * the identified merge units. Each task is a sequential merge of the data + * ranges specified by the merge unit bounds. The current implementation is + * fairly naive, just using a priority queue, but we could imagine doing + * something more interesting here. + * + * Our implementation assumes a single contiguous output buffer. + * Each merge unit can use its bounds to determine which positions in the output + * buffer it is meant to write to. */ #ifndef TILEDB_PARALLEL_MERGE_H @@ -83,8 +138,8 @@ struct MergeUnit; * Provides methods for waiting on the incremental asynchronous output * of the merge operation. * - * FIXME: need to move the comparator here somehow so that way - * it doesn't have to have a longer lifetime from the caller + * The caller is responsible for ensuring that the input data, output data, + * and comparator all out-live the `ParallelMergeFuture`. */ struct ParallelMergeFuture { ParallelMergeFuture( @@ -164,6 +219,9 @@ struct MergeUnit { , ends(&resource) { } + /** + * @return the number of data items contained inside this merge unit + */ uint64_t num_items() const { uint64_t total_items = 0; for (size_t i = 0; i < starts.size(); i++) { @@ -172,6 +230,9 @@ struct MergeUnit { return total_items; } + /** + * @return the starting position in the output where this merge unit writes to + */ uint64_t output_start() const { uint64_t total_bound = 0; for (size_t i = 0; i < ends.size(); i++) { @@ -180,6 +241,10 @@ struct MergeUnit { return total_bound; } + /** + * @return the upper bound position in the output where this merge unit writes + * to + */ uint64_t output_end() const { uint64_t total_bound = 0; for (size_t i = 0; i < ends.size(); i++) { @@ -207,6 +272,10 @@ class ParallelMerge { typedef std::span> Streams; private: + /** + * Comparator for std::span which defers comparison to the first element of + * the span. + */ struct span_greater { span_greater(Compare& cmp) : cmp_(cmp) { @@ -219,6 +288,11 @@ class ParallelMerge { Compare cmp_; }; + /** + * Runs a single-threaded tournament merge of the ranges of `streams` + * identified by `unit`. Writes results to the positions of `output` + * identified by `unit`. + */ static Status tournament_merge( Streams streams, Compare* cmp, const MergeUnit& unit, T* output) { std::vector> container; @@ -260,13 +334,21 @@ class ParallelMerge { } } + /** + * Identifies the upper bounds in each of `streams` where the items + * are less than the split point. + * + * `which` is the index of the stream we want to use for the split point. + */ static MergeUnit split_point_stream_bounds( Streams streams, Compare& cmp, tdb::pmr::memory_resource& memory, uint64_t which, const MergeUnit& search_bounds) { - const T& split_point = streams[which][search_bounds.ends[which] - 1]; + const auto split_point_idx = + (search_bounds.starts[which] + search_bounds.ends[which] + 1) / 2 - 1; + const T& split_point = streams[which][split_point_idx]; MergeUnit output(memory); output.starts = search_bounds.starts; @@ -275,7 +357,7 @@ class ParallelMerge { for (uint64_t i = 0; i < streams.size(); i++) { if (i == which) { output.starts[i] = search_bounds.starts[i]; - output.ends.push_back(search_bounds.ends[i]); + output.ends.push_back(split_point_idx + 1); } else { std::span substream( streams[i].begin() + search_bounds.starts[i], @@ -294,6 +376,9 @@ class ParallelMerge { enum class SearchStep { Stalled, MadeProgress, Converged }; + /** + * Holds state for searching for a merge unit of size `target_items`. + */ struct SearchMergeBoundary { Streams streams_; Compare& cmp_; @@ -337,23 +422,13 @@ class ParallelMerge { MergeUnit split_point_bounds(memory_); { - // temporarily shrink the split point stream bounds to indicate the - // split point - auto original_end = search_bounds_.ends[split_point_stream_]; if (search_bounds_.starts[split_point_stream_] >= search_bounds_.ends[split_point_stream_]) { throw ParallelMergeException("Internal error: invalid split point"); } - search_bounds_.ends[split_point_stream_] = - (search_bounds_.starts[split_point_stream_] + - search_bounds_.ends[split_point_stream_] + 1) / - 2; - split_point_bounds = split_point_stream_bounds( streams_, cmp_, memory_, split_point_stream_, search_bounds_); - - search_bounds_.ends[split_point_stream_] = original_end; } const uint64_t num_split_point_items = split_point_bounds.num_items(); @@ -407,6 +482,10 @@ class ParallelMerge { } }; + /** + * @return a MergeUnit of size `target_items` whose starting positions are + * zero for each stream + */ static MergeUnit identify_merge_unit( Streams streams, Compare* cmp, @@ -434,6 +513,11 @@ class ParallelMerge { } } + /** + * Identifies the next merge unit and then spawns tasks + * to begin the tournament merge of that unit, and also identify + * the next merge unit if there is another. + */ static Status spawn_next_merge_unit( tiledb::common::ThreadPool* pool, Streams streams, From efdeb535f4c63d8dcea67f6e4af24103e3e49d44 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 3 Jan 2025 13:27:22 -0500 Subject: [PATCH 108/228] Move CApiArray to array_helpers.h --- test/src/unit-sparse-global-order-reader.cc | 52 +----------- test/support/src/array_helpers.h | 92 +++++++++++++++++++++ 2 files changed, 93 insertions(+), 51 deletions(-) create mode 100644 test/support/src/array_helpers.h diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 53414657634..85068b6c984 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -31,6 +31,7 @@ */ #include "test/support/rapidcheck/array_templates.h" +#include "test/support/src/array_helpers.h" #include "test/support/src/array_templates.h" #include "test/support/src/error_helpers.h" #include "test/support/src/helpers.h" @@ -375,57 +376,6 @@ struct FxRun2D { } }; -/** - * RAII to make sure we close our arrays so that keeping the same array URI - * open from one test to the next doesn't muck things up - * (this is especially important for rapidcheck) - */ -struct CApiArray { - tiledb_ctx_t* ctx_; - tiledb_array_t* array_; - - CApiArray() - : ctx_(nullptr) - , array_(nullptr) { - } - - CApiArray(tiledb_ctx_t* ctx, const char* uri, tiledb_query_type_t mode) - : ctx_(ctx) - , array_(nullptr) { - auto rc = tiledb_array_alloc(ctx, uri, &array_); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array_, mode); - REQUIRE(rc == TILEDB_OK); - } - - CApiArray(CApiArray&& from) - : ctx_(from.ctx_) - , array_(from.movefrom()) { - } - - ~CApiArray() { - if (array_) { - auto rc = tiledb_array_close(ctx_, array_); - REQUIRE(rc == TILEDB_OK); - tiledb_array_free(&array_); - } - } - - tiledb_array_t* movefrom() { - auto array = array_; - array_ = nullptr; - return array; - } - - operator tiledb_array_t*() const { - return array_; - } - - tiledb_array_t* operator->() const { - return array_; - } -}; - /** * Describes types which can be used with `CSparseGlobalOrderFx::run`. */ diff --git a/test/support/src/array_helpers.h b/test/support/src/array_helpers.h new file mode 100644 index 00000000000..f7f4e71506c --- /dev/null +++ b/test/support/src/array_helpers.h @@ -0,0 +1,92 @@ +/** + * @file array_schema.h + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2017-2024 TileDB, 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. + * + * @section DESCRIPTION + * + * This file declares some array test suite helper functions. + */ + +#ifndef TILEDB_TEST_ARRAY_HELPERS_H +#define TILEDB_TEST_ARRAY_HELPERS_H + +#include "tiledb/sm/c_api/tiledb.h" + +namespace tiledb::test { + +/** + * RAII to make sure we close our arrays so that keeping the same array URI + * open from one test to the next doesn't muck things up + * (this is especially important for rapidcheck) + */ +struct CApiArray { + tiledb_ctx_t* ctx_; + tiledb_array_t* array_; + + CApiArray() + : ctx_(nullptr) + , array_(nullptr) { + } + + CApiArray(tiledb_ctx_t* ctx, const char* uri, tiledb_query_type_t mode) + : ctx_(ctx) + , array_(nullptr) { + auto rc = tiledb_array_alloc(ctx, uri, &array_); + REQUIRE(rc == TILEDB_OK); + rc = tiledb_array_open(ctx, array_, mode); + REQUIRE(rc == TILEDB_OK); + } + + CApiArray(CApiArray&& from) + : ctx_(from.ctx_) + , array_(from.movefrom()) { + } + + ~CApiArray() { + if (array_) { + auto rc = tiledb_array_close(ctx_, array_); + REQUIRE(rc == TILEDB_OK); + tiledb_array_free(&array_); + } + } + + tiledb_array_t* movefrom() { + auto array = array_; + array_ = nullptr; + return array; + } + + operator tiledb_array_t*() const { + return array_; + } + + tiledb_array_t* operator->() const { + return array_; + } +}; +} // namespace tiledb::test + +#endif From 46f67d9a8a4b9ca10b667ec15986c2e522754f7c Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 3 Jan 2025 15:26:02 -0500 Subject: [PATCH 109/228] Refactor SparseGlobalOrderMemoryBudget --- test/src/unit-sparse-global-order-reader.cc | 58 ++------------------- test/support/CMakeLists.txt | 1 + test/support/src/array_helpers.cc | 42 +++++++++++++++ test/support/src/array_helpers.h | 39 +++++++++++--- test/support/src/error_helpers.h | 24 ++++++--- test/support/src/helpers.cc | 7 +++ 6 files changed, 105 insertions(+), 66 deletions(-) create mode 100644 test/support/src/array_helpers.cc diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 85068b6c984..e69690106f1 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -76,24 +76,6 @@ Gen>> make_subarray_1d( /* STRUCT DEFINITION */ /* ********************************* */ -/** - * Encapsulates memory budget configuration parameters for the sparse global - * order reader - */ -struct MemoryBudget { - std::string total_budget_; - std::string ratio_tile_ranges_; - std::string ratio_array_data_; - std::string ratio_coords_; - - MemoryBudget() - : total_budget_("1048576") - , ratio_tile_ranges_("0.1") - , ratio_array_data_("0.1") - , ratio_coords_("0.5") { - } -}; - /** * Options for configuring the CSparseGlobalFx default 1D array */ @@ -132,7 +114,7 @@ struct FxRun1D { std::vector> subarray; DefaultArray1DConfig array; - MemoryBudget memory; + SparseGlobalOrderReaderMemoryBudget memory; uint64_t tile_capacity() const { return array.capacity; @@ -232,7 +214,7 @@ struct FxRun2D { templates::Dimension d1; templates::Dimension d2; - MemoryBudget memory; + SparseGlobalOrderReaderMemoryBudget memory; FxRun2D() : num_user_cells(8) @@ -403,7 +385,7 @@ struct CSparseGlobalOrderFx { const char* ARRAY_NAME = "test_sparse_global_order"; tiledb_array_t* array_ = nullptr; - MemoryBudget memory_; + SparseGlobalOrderReaderMemoryBudget memory_; template void create_default_array_1d( @@ -487,7 +469,7 @@ CSparseGlobalOrderFx::~CSparseGlobalOrderFx() { } void CSparseGlobalOrderFx::reset_config() { - memory_ = MemoryBudget(); + memory_ = SparseGlobalOrderReaderMemoryBudget(); update_config(); } @@ -508,37 +490,7 @@ void CSparseGlobalOrderFx::update_config() { &error) == TILEDB_OK); REQUIRE(error == nullptr); - REQUIRE( - tiledb_config_set( - config, - "sm.mem.total_budget", - memory_.total_budget_.c_str(), - &error) == TILEDB_OK); - REQUIRE(error == nullptr); - - REQUIRE( - tiledb_config_set( - config, - "sm.mem.reader.sparse_global_order.ratio_tile_ranges", - memory_.ratio_tile_ranges_.c_str(), - &error) == TILEDB_OK); - REQUIRE(error == nullptr); - - REQUIRE( - tiledb_config_set( - config, - "sm.mem.reader.sparse_global_order.ratio_array_data", - memory_.ratio_array_data_.c_str(), - &error) == TILEDB_OK); - REQUIRE(error == nullptr); - - REQUIRE( - tiledb_config_set( - config, - "sm.mem.reader.sparse_global_order.ratio_coords", - memory_.ratio_coords_.c_str(), - &error) == TILEDB_OK); - REQUIRE(error == nullptr); + REQUIRE(memory_.apply(config) == nullptr); REQUIRE(tiledb_ctx_alloc(config, &ctx_) == TILEDB_OK); REQUIRE(error == nullptr); diff --git a/test/support/CMakeLists.txt b/test/support/CMakeLists.txt index 92f1ed59449..b950caebc27 100644 --- a/test/support/CMakeLists.txt +++ b/test/support/CMakeLists.txt @@ -36,6 +36,7 @@ list(APPEND TILEDB_CORE_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/tiledb/sm/c_api") # Gather the test source files set(TILEDB_TEST_SUPPORT_SOURCES + src/array_helpers.cc src/array_schema_helpers.cc src/ast_helpers.h src/ast_helpers.cc diff --git a/test/support/src/array_helpers.cc b/test/support/src/array_helpers.cc new file mode 100644 index 00000000000..22218405ff0 --- /dev/null +++ b/test/support/src/array_helpers.cc @@ -0,0 +1,42 @@ +#include + +namespace tiledb::test { + +tiledb_error_t* SparseGlobalOrderReaderMemoryBudget::apply( + tiledb_config_t* config) { + tiledb_error_t* error; + + if (tiledb_config_set( + config, "sm.mem.total_budget", total_budget_.c_str(), &error) != + TILEDB_OK) { + return error; + } + + if (tiledb_config_set( + config, + "sm.mem.reader.sparse_global_order.ratio_tile_ranges", + ratio_tile_ranges_.c_str(), + &error) != TILEDB_OK) { + return error; + } + + if (tiledb_config_set( + config, + "sm.mem.reader.sparse_global_order.ratio_array_data", + ratio_array_data_.c_str(), + &error) != TILEDB_OK) { + return error; + } + + if (tiledb_config_set( + config, + "sm.mem.reader.sparse_global_order.ratio_coords", + ratio_coords_.c_str(), + &error) != TILEDB_OK) { + return error; + } + + return nullptr; +} + +} // namespace tiledb::test diff --git a/test/support/src/array_helpers.h b/test/support/src/array_helpers.h index f7f4e71506c..c7e01dff37b 100644 --- a/test/support/src/array_helpers.h +++ b/test/support/src/array_helpers.h @@ -33,8 +33,11 @@ #ifndef TILEDB_TEST_ARRAY_HELPERS_H #define TILEDB_TEST_ARRAY_HELPERS_H +#include "test/support/src/error_helpers.h" #include "tiledb/sm/c_api/tiledb.h" +#include + namespace tiledb::test { /** @@ -54,10 +57,8 @@ struct CApiArray { CApiArray(tiledb_ctx_t* ctx, const char* uri, tiledb_query_type_t mode) : ctx_(ctx) , array_(nullptr) { - auto rc = tiledb_array_alloc(ctx, uri, &array_); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array_, mode); - REQUIRE(rc == TILEDB_OK); + throw_if_error(ctx, tiledb_array_alloc(ctx, uri, &array_)); + throw_if_error(ctx, tiledb_array_open(ctx, array_, mode)); } CApiArray(CApiArray&& from) @@ -67,8 +68,8 @@ struct CApiArray { ~CApiArray() { if (array_) { - auto rc = tiledb_array_close(ctx_, array_); - REQUIRE(rc == TILEDB_OK); + // yes this may std::terminate but hey it's test code + throw_if_error(ctx_, tiledb_array_close(ctx_, array_)); tiledb_array_free(&array_); } } @@ -87,6 +88,32 @@ struct CApiArray { return array_; } }; + +/** + * Encapsulates memory budget configuration parameters for the sparse global + * order reader + */ +struct SparseGlobalOrderReaderMemoryBudget { + std::string total_budget_; + std::string ratio_tile_ranges_; + std::string ratio_array_data_; + std::string ratio_coords_; + + SparseGlobalOrderReaderMemoryBudget() + : total_budget_("1048576") + , ratio_tile_ranges_("0.1") + , ratio_array_data_("0.1") + , ratio_coords_("0.5") { + } + + /** + * Apply this memory budget to `config`. + * + * @return an error if one occurred, or nullptr if successful + */ + tiledb_error_t* apply(tiledb_config_t* config); +}; + } // namespace tiledb::test #endif diff --git a/test/support/src/error_helpers.h b/test/support/src/error_helpers.h index d9c603ead4a..20246bbbc6c 100644 --- a/test/support/src/error_helpers.h +++ b/test/support/src/error_helpers.h @@ -35,6 +35,9 @@ #include "tiledb.h" +#include +#include + /** * Calls a C API function and returns its status if it is not TILEDB_OK. */ @@ -74,20 +77,27 @@ std::string error_if_any(tiledb_ctx_t* ctx, CAPIReturn apirc) { } tiledb_error_t* error = NULL; - auto rc = tiledb_ctx_get_last_error(ctx, &error); - REQUIRE(rc == TILEDB_OK); - if (error == nullptr) { + if (tiledb_ctx_get_last_error(ctx, &error) != TILEDB_OK) { + return "Internal error: tiledb_ctx_get_last_error"; + } else if (error == nullptr) { // probably should be unreachable return ""; } const char* msg; - rc = tiledb_error_message(error, &msg); - REQUIRE(rc == TILEDB_OK); - - return std::string(msg); + if (tiledb_error_message(error, &msg) != TILEDB_OK) { + return "Internal error: tiledb_error_message"; + } else { + return std::string(msg); + } } +/** + * Throws a `std::runtime_error` if the operation returning `thing` + * did not return `TILEDB_OK`. + */ +void throw_if_error(tiledb_ctx_t* ctx, capi_return_t thing); + } // namespace tiledb::test #endif diff --git a/test/support/src/helpers.cc b/test/support/src/helpers.cc index cb3c1836e02..8bac0df5d2c 100644 --- a/test/support/src/helpers.cc +++ b/test/support/src/helpers.cc @@ -173,6 +173,13 @@ void require_tiledb_ok(tiledb_ctx_t* ctx, int rc) { REQUIRE(rc == TILEDB_OK); } +void throw_if_error(tiledb_ctx_t* ctx, capi_return_t thing) { + auto err = error_if_any(ctx, thing); + if (err != "") { + throw std::runtime_error(err); + } +} + int store_g_vfs(std::string&& vfs, std::vector vfs_fs) { if (!vfs.empty()) { if (std::find(vfs_fs.begin(), vfs_fs.end(), vfs) == vfs_fs.end()) { From ab56a4d65a838f0c25292a7aa6fa15ab1a9cd939 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 3 Jan 2025 15:26:13 -0500 Subject: [PATCH 110/228] preprocess_tile_order_.num_tiles_ = 0 --- tiledb/sm/query/readers/sparse_global_order_reader.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index af4deb672bd..a5dbb45abce 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -156,7 +156,7 @@ SparseGlobalOrderReader::SparseGlobalOrderReader( "sm.query.sparse_global_order.preprocess_tile_merge") .value_or(0); preprocess_tile_order_.cursor_ = 0; - preprocess_tile_order_.num_tiles_ = 1; // will be adjusted later if needed + preprocess_tile_order_.num_tiles_ = 0; // will be adjusted later if needed if (!preprocess_tile_order_.enabled_) { all_fragment_tile_order_.memory_used_for_coords_.resize( From ee3278276e0f63461b41ec9ac997b9f89149b3bb Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 3 Jan 2025 16:18:43 -0500 Subject: [PATCH 111/228] Move query_applicator into array_templates.h and change macro to ASSERTER --- test/src/unit-sparse-global-order-reader.cc | 150 ++++---------------- test/support/assert_helpers.h | 113 +++++++++++++++ test/support/src/array_templates.h | 99 +++++++++++++ test/support/src/error_helpers.h | 10 +- test/support/tdb_rapidcheck.h | 80 +---------- 5 files changed, 250 insertions(+), 202 deletions(-) create mode 100644 test/support/assert_helpers.h diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index e69690106f1..b4e698c3298 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -56,6 +56,8 @@ #include #include +#include + #include #include @@ -66,6 +68,7 @@ using tiledb::sm::Datatype; using tiledb::test::templates::AttributeType; using tiledb::test::templates::DimensionType; using tiledb::test::templates::FragmentType; +using tiledb::test::templates::query_applicator; namespace rc { Gen>> make_subarray_1d( @@ -502,10 +505,10 @@ void CSparseGlobalOrderFx::create_default_array_1d( const DefaultArray1DConfig& config) { tiledb_object_t type; auto rc = tiledb_object_type(ctx_, array_name_.c_str(), &type); - RCCATCH_REQUIRE(rc == TILEDB_OK); + ASSERTER(rc == TILEDB_OK); if (type == TILEDB_ARRAY) { rc = tiledb_array_delete(ctx_, array_name_.c_str()); - RCCATCH_REQUIRE("" == error_if_any(rc)); + ASSERTER("" == error_if_any(rc)); } tiledb::test::create_array( @@ -556,117 +559,22 @@ void CSparseGlobalOrderFx::write_1d_fragment( // Create the query. tiledb_query_t* query; auto rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); - RCCATCH_REQUIRE(rc == TILEDB_OK); + ASSERTER(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); - RCCATCH_REQUIRE(rc == TILEDB_OK); + ASSERTER(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer(ctx_, query, "a", data, data_size); - RCCATCH_REQUIRE(rc == TILEDB_OK); + ASSERTER(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer(ctx_, query, "d", coords, coords_size); - RCCATCH_REQUIRE(rc == TILEDB_OK); + ASSERTER(rc == TILEDB_OK); // Submit query. rc = tiledb_query_submit(ctx_, query); - RCCATCH_REQUIRE("" == error_if_any(rc)); + ASSERTER("" == error_if_any(rc)); // Clean up. tiledb_query_free(&query); } -/** - * Binds variadic field data to a tiledb query - */ -template -struct query_applicator { - /** - * @return a tuple containing the size of each input field - */ - static auto make_field_sizes( - const std::tuple fields, - uint64_t cell_limit = std::numeric_limits::max()) { - std::optional num_cells; - auto make_field_size = [&](const std::vector& field) { - const uint64_t field_cells = std::min(cell_limit, field.size()); - const uint64_t field_size = field_cells * sizeof(T); - if (num_cells.has_value()) { - // precondition: each field must have the same number of cells - RCCATCH_REQUIRE(field_cells == num_cells.value()); - } else { - num_cells.emplace(field_cells); - } - return field_size; - }; - - return std::apply( - [make_field_size](const auto&... field) { - return std::make_tuple(make_field_size(field)...); - }, - fields); - } - - /** - * Sets buffers on `query` for the variadic `fields` and `fields_sizes` - */ - static void set( - tiledb_ctx_t* ctx, - tiledb_query_t* query, - auto& field_sizes, - std::tuple fields, - const char* basename, - uint64_t cell_offset = 0) { - auto set_data_buffer = - [&](const std::string& name, auto& field, uint64_t& field_size) { - auto ptr = const_cast( - static_cast(&field.data()[cell_offset])); - auto rc = tiledb_query_set_data_buffer( - ctx, query, name.c_str(), ptr, &field_size); - RCCATCH_REQUIRE("" == error_if_any(ctx, rc)); - }; - - uint64_t d = 1; - std::apply( - [&](const auto&... field) { - std::apply( - [&](Us&... field_size) { - (set_data_buffer( - basename + std::to_string(d++), field, field_size), - ...); - }, - field_sizes); - }, - fields); - } - - /** - * @return the number of cells written into `fields` by a read query - */ - static uint64_t num_cells(const auto& fields, const auto& field_sizes) { - std::optional num_cells; - - auto check_field = [&]( - const std::vector& field, uint64_t field_size) { - RCCATCH_REQUIRE(field_size % sizeof(T) == 0); - RCCATCH_REQUIRE(field_size <= field.size() * sizeof(T)); - if (num_cells.has_value()) { - RCCATCH_REQUIRE(num_cells.value() == field_size / sizeof(T)); - } else { - num_cells.emplace(field_size / sizeof(T)); - } - }; - - std::apply( - [&](const auto&... field) { - std::apply( - [&](const auto&... field_size) { - (check_field(field, field_size), ...); - }, - field_sizes); - }, - fields); - - return num_cells.value(); - } -}; - /** * Writes a generic `FragmentType` into the array. */ @@ -689,9 +597,9 @@ void CSparseGlobalOrderFx::write_fragment(const Fragment& fragment) { // Create the query. tiledb_query_t* query; auto rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); - RCCATCH_REQUIRE(rc == TILEDB_OK); + ASSERTER(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); - RCCATCH_REQUIRE(rc == TILEDB_OK); + ASSERTER(rc == TILEDB_OK); // add dimensions to query [&](std::tuple dims) { @@ -707,7 +615,7 @@ void CSparseGlobalOrderFx::write_fragment(const Fragment& fragment) { // Submit query. rc = tiledb_query_submit(ctx_, query); - RCCATCH_REQUIRE("" == error_if_any(rc)); + ASSERTER("" == error_if_any(rc)); // check that sizes match what we expect const uint64_t expect_num_cells = fragment.size(); @@ -718,8 +626,8 @@ void CSparseGlobalOrderFx::write_fragment(const Fragment& fragment) { return query_applicator::num_cells(atts, attribute_sizes); }(attributes); - RCCATCH_REQUIRE(dim_num_cells == expect_num_cells); - RCCATCH_REQUIRE(att_num_cells == expect_num_cells); + ASSERTER(dim_num_cells == expect_num_cells); + ASSERTER(att_num_cells == expect_num_cells); // Clean up. tiledb_query_free(&query); @@ -2399,10 +2307,10 @@ template void CSparseGlobalOrderFx::create_array(const Instance& instance) { tiledb_object_t type; auto rc = tiledb_object_type(ctx_, array_name_.c_str(), &type); - RCCATCH_REQUIRE(rc == TILEDB_OK); + ASSERTER(rc == TILEDB_OK); if (type == TILEDB_ARRAY) { rc = tiledb_array_delete(ctx_, array_name_.c_str()); - RCCATCH_REQUIRE("" == error_if_any(rc)); + ASSERTER("" == error_if_any(rc)); } const auto dimensions = instance.dimensions(); @@ -2468,7 +2376,7 @@ void CSparseGlobalOrderFx::create_array(const Instance& instance) { */ template void CSparseGlobalOrderFx::run(Instance instance) { - RCCATCH_REQUIRE(instance.num_user_cells > 0); + ASSERTER(instance.num_user_cells > 0); reset_config(); @@ -2539,9 +2447,9 @@ void CSparseGlobalOrderFx::run(Instance instance) { // Create query tiledb_query_t* query; auto rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); - RCCATCH_REQUIRE(rc == TILEDB_OK); + ASSERTER(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); - RCCATCH_REQUIRE(rc == TILEDB_OK); + ASSERTER(rc == TILEDB_OK); if (!instance.subarray.empty()) { tiledb_subarray_t* subarray; @@ -2592,7 +2500,7 @@ void CSparseGlobalOrderFx::run(Instance instance) { "fragments in global order") != std::string::npos) { if (!vfs_test_setup_.is_rest()) { // skip for REST since we will not have access to tile sizes - RCCATCH_REQUIRE(!can_complete_in_memory_budget( + ASSERTER(!can_complete_in_memory_budget( ctx_, array_name_.c_str(), instance)); } tiledb_query_free(&query); @@ -2603,13 +2511,13 @@ void CSparseGlobalOrderFx::run(Instance instance) { tiledb_query_free(&query); return; } else { - RCCATCH_REQUIRE("" == err); + ASSERTER("" == err); } } tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); - RCCATCH_REQUIRE(rc == TILEDB_OK); + ASSERTER(rc == TILEDB_OK); const uint64_t dim_num_cells = [&](auto dims) { return query_applicator::num_cells( @@ -2620,12 +2528,12 @@ void CSparseGlobalOrderFx::run(Instance instance) { atts, attribute_sizes); }(outatts); - RCCATCH_REQUIRE(dim_num_cells == att_num_cells); + ASSERTER(dim_num_cells == att_num_cells); if (dim_num_cells < instance.num_user_cells) { - RCCATCH_REQUIRE(status == TILEDB_COMPLETED); + ASSERTER(status == TILEDB_COMPLETED); } else { - RCCATCH_REQUIRE(dim_num_cells == instance.num_user_cells); + ASSERTER(dim_num_cells == instance.num_user_cells); } outcursor += dim_num_cells; @@ -2643,7 +2551,7 @@ void CSparseGlobalOrderFx::run(Instance instance) { [outcursor](auto&... outfield) { (outfield.resize(outcursor), ...); }, std::tuple_cat(outdims, outatts)); - RCCATCH_REQUIRE(expect.dimensions() == outdims); + ASSERTER(expect.dimensions() == outdims); // Checking attributes is more complicated because equal coords // can manifest their attributes in any order. @@ -2672,7 +2580,7 @@ void CSparseGlobalOrderFx::run(Instance instance) { expectattsrun.insert(viewtuple(expect.attributes(), j)); } - RCCATCH_REQUIRE(outattsrun == expectattsrun); + ASSERTER(outattsrun == expectattsrun); attcursor += runlength; runlength = 1; @@ -2682,7 +2590,7 @@ void CSparseGlobalOrderFx::run(Instance instance) { // lastly, check the correctness of our memory budgeting function // (skip for REST since we will not have access to tile sizes) if (!vfs_test_setup_.is_rest()) { - RCCATCH_REQUIRE( + ASSERTER( can_complete_in_memory_budget(ctx_, array_name_.c_str(), instance)); } } diff --git a/test/support/assert_helpers.h b/test/support/assert_helpers.h new file mode 100644 index 00000000000..5061a39ab58 --- /dev/null +++ b/test/support/assert_helpers.h @@ -0,0 +1,113 @@ +/** + * @file assert_helpers.h + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2022-2024 TileDB, 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. + * + * @section DESCRIPTION + * + * Provides definitions of macros which enable dispatching assertion + * failures to library code, depending on the `Asserter` + * type in the scope of the caller. + * + * This is desirable for writing code which might want to be + * invoked in the context of multiple different libraries, such + * as a helper function that could be called from a Catch2 TEST_CASE + * or a rapidcheck property. + */ + +#ifndef TILEDB_ASSERT_HELPERS_H +#define TILEDB_ASSERT_HELPERS_H + +#include +#include + +namespace tiledb::test { + +/** + * Marker that a template is instantiated by top-level CATCH code + */ +struct AsserterCatch {}; + +/** + * Marker that a template is instantiated by a rapidcheck property + */ +struct AsserterRapidcheck {}; + +} // namespace tiledb::test + +/** + * Helper macro for running an assert in a context + * where we might want to dispatch assertion failure behavior + * to one of a few possible different libraries depending + * on the caller + * (e.g. a function which can be called from either a Catch2 + * TEST_CASE or from a rapidcheck property wants to use REQUIRE + * and RC_ASSERT respectively). + * + * Expects a type named `Asserter` to be either `AsserterCatch` or + * `AsserterRapidcheck`. + * + * This expands to REQUIRE for `AsserterCatch` and RC_ASSERT for + * `AsserterRapidcheck`. For both type markers this will throw an exception. + */ +#define ASSERTER(...) \ + do { \ + static_assert( \ + std::is_same::value || \ + std::is_same::value); \ + if (std::is_same::value) { \ + REQUIRE(__VA_ARGS__); \ + } else { \ + RC_ASSERT(__VA_ARGS__); \ + } \ + } while (0) + +/** + * Helper macro for asserting that an expression throws an exception + * in a context where we might want to dispatch assertion failure behavior + * to one of a few possible different libraries depending on the caller + * (e.g. a function which can be called from either a Catch2 + * TEST_CASE or from a rapidcheck property wants to use REQUIRE + * and RC_ASSERT respectively). + * + * Expects a type named `Asserter` to be either `AsserterCatch` or + * `AsserterRapidcheck`. + * + * This expands to REQUIRE_THROWS for `AsserterCatch` and RC_ASSERT_THROWS for + * `AsserterRapidcheck`. For both type markers this will throw an exception. + */ +#define ASSERTER_THROWS(...) \ + do { \ + static_assert( \ + std::is_same::value || \ + std::is_same::value); \ + if (std::is_same::value) { \ + REQUIRE_THROWS(__VA_ARGS__); \ + } else { \ + RC_ASSERT_THROWS(__VA_ARGS__); \ + } \ + } while (0) + +#endif diff --git a/test/support/src/array_templates.h b/test/support/src/array_templates.h index 17f4f1590d5..752dab1cf85 100644 --- a/test/support/src/array_templates.h +++ b/test/support/src/array_templates.h @@ -34,9 +34,13 @@ #ifndef TILEDB_ARRAY_TEMPLATES_H #define TILEDB_ARRAY_TEMPLATES_H +#include "tiledb.h" #include "tiledb/type/datatype_traits.h" #include "tiledb/type/range/range.h" +#include +#include + #include #include #include @@ -245,6 +249,101 @@ struct Fragment2D { } }; +/** + * Binds variadic field data to a tiledb query + */ +template +struct query_applicator { + /** + * @return a tuple containing the size of each input field + */ + static auto make_field_sizes( + const std::tuple fields, + uint64_t cell_limit = std::numeric_limits::max()) { + std::optional num_cells; + auto make_field_size = [&](const std::vector& field) { + const uint64_t field_cells = std::min(cell_limit, field.size()); + const uint64_t field_size = field_cells * sizeof(T); + if (num_cells.has_value()) { + // precondition: each field must have the same number of cells + ASSERTER(field_cells == num_cells.value()); + } else { + num_cells.emplace(field_cells); + } + return field_size; + }; + + return std::apply( + [make_field_size](const auto&... field) { + return std::make_tuple(make_field_size(field)...); + }, + fields); + } + + /** + * Sets buffers on `query` for the variadic `fields` and `fields_sizes` + */ + static void set( + tiledb_ctx_t* ctx, + tiledb_query_t* query, + auto& field_sizes, + std::tuple fields, + const char* basename, + uint64_t cell_offset = 0) { + auto set_data_buffer = + [&](const std::string& name, auto& field, uint64_t& field_size) { + auto ptr = const_cast( + static_cast(&field.data()[cell_offset])); + auto rc = tiledb_query_set_data_buffer( + ctx, query, name.c_str(), ptr, &field_size); + ASSERTER("" == error_if_any(ctx, rc)); + }; + + uint64_t d = 1; + std::apply( + [&](const auto&... field) { + std::apply( + [&](Us&... field_size) { + (set_data_buffer( + basename + std::to_string(d++), field, field_size), + ...); + }, + field_sizes); + }, + fields); + } + + /** + * @return the number of cells written into `fields` by a read query + */ + static uint64_t num_cells(const auto& fields, const auto& field_sizes) { + std::optional num_cells; + + auto check_field = [&]( + const std::vector& field, uint64_t field_size) { + ASSERTER(field_size % sizeof(T) == 0); + ASSERTER(field_size <= field.size() * sizeof(T)); + if (num_cells.has_value()) { + ASSERTER(num_cells.value() == field_size / sizeof(T)); + } else { + num_cells.emplace(field_size / sizeof(T)); + } + }; + + std::apply( + [&](const auto&... field) { + std::apply( + [&](const auto&... field_size) { + (check_field(field, field_size), ...); + }, + field_sizes); + }, + fields); + + return num_cells.value(); + } +}; + } // namespace tiledb::test::templates #endif diff --git a/test/support/src/error_helpers.h b/test/support/src/error_helpers.h index 20246bbbc6c..8b4ec858f67 100644 --- a/test/support/src/error_helpers.h +++ b/test/support/src/error_helpers.h @@ -35,6 +35,8 @@ #include "tiledb.h" +#include + #include #include @@ -52,10 +54,10 @@ /** * Asserts that a C API call does not return error. */ -#define TRY(ctx, thing) \ - do { \ - auto rc = (thing); \ - RCCATCH_REQUIRE("" == tiledb::test::error_if_any(ctx, rc)); \ +#define TRY(ctx, thing) \ + do { \ + auto rc = (thing); \ + ASSERTER("" == tiledb::test::error_if_any(ctx, rc)); \ } while (0) namespace tiledb::test { diff --git a/test/support/tdb_rapidcheck.h b/test/support/tdb_rapidcheck.h index a040c02f827..7e6d90a22bc 100644 --- a/test/support/tdb_rapidcheck.h +++ b/test/support/tdb_rapidcheck.h @@ -28,7 +28,9 @@ * @section DESCRIPTION * * This file wraps and for convenience - * (and compatibility due to a snag with ). + * (and compatibility due to a snag with ) + * and contains other definitions which may be useful for writing + * rapidcheck properties. */ #ifndef TILEDB_MISC_TDB_RAPIDCHECK_H @@ -46,82 +48,6 @@ #include -namespace tiledb::test { - -/** - * Marker that a template is instantiated by top-level CATCH code - */ -struct AsserterCatch {}; - -/** - * Marker that a template is instantiated by a rapidcheck property - */ -struct AsserterRapidcheck {}; - -} // namespace tiledb::test - -/** - * Helper macro for running an assert in a context - * where it could be either in a top-level catch test, - * or in a rapidcheck property - * (e.g. a function which could be called from either) - * - * Expects a type named `Asserter` to be either `AsserterCatch` or - * `AsserterRapidcheck`. - * - * This expands to REQUIRE for `AsserterCatch` and RC_ASSERT for - * `AsserterRapidcheck`. For both type markers this will throw an exception. - */ -#define RCCATCH_REQUIRE(...) \ - do { \ - static_assert( \ - std::is_same::value || \ - std::is_same::value); \ - if (std::is_same::value) { \ - REQUIRE(__VA_ARGS__); \ - } else { \ - RC_ASSERT(__VA_ARGS__); \ - } \ - } while (0) - -/** - * Helper macro for running an assert in a context - * where it could be either in a top-level catch test, - * or in a rapidcheck property - * (e.g. a function which could be called from either) - * - * Expects a type named `Asserter` to be either `AsserterCatch` or - * `AsserterRapidcheck`. - * - * This expands to CHECK for `AsserterCatch` and RC_ASSERT for - * `AsserterRapidcheck`. For `AsserterCatch`, this will not throw an exception - - * the test will continue. For `AsserterRapidcheck` this will throw an - * exception. - */ -#define RCCATCH_CHECK(...) \ - do { \ - static_assert( \ - std::is_same::value || \ - std::is_same::value); \ - if (std::is_same::value) { \ - CHECK(__VA_ARGS__); \ - } else { \ - RC_ASSERT(__VA_ARGS__); \ - } \ - } while (0) - -#define RCCATCH_THROWS(...) \ - do { \ - static_assert( \ - std::is_same::value || \ - std::is_same::value); \ - if (std::is_same::value) { \ - REQUIRE_THROWS(__VA_ARGS__); \ - } else { \ - RC_ASSERT_THROWS(__VA_ARGS__); \ - } \ - } while (0) - namespace rc { /** From 7372f6f08f8572b15bf7415999a973cc827c167b Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 3 Jan 2025 16:51:31 -0500 Subject: [PATCH 112/228] Use function for query_applicator to determine field name --- test/src/unit-sparse-global-order-reader.cc | 22 +++++++++++++++++---- test/support/src/array_templates.h | 6 ++---- 2 files changed, 20 insertions(+), 8 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index b4e698c3298..01b9e2a6b75 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -604,13 +604,17 @@ void CSparseGlobalOrderFx::write_fragment(const Fragment& fragment) { // add dimensions to query [&](std::tuple dims) { query_applicator::set( - ctx_, query, dimension_sizes, dims, "d"); + ctx_, query, dimension_sizes, dims, [](unsigned d) { + return "d" + std::to_string(d); + }); }(dimensions); // add attributes to query [&](std::tuple atts) { query_applicator::set( - ctx_, query, attribute_sizes, atts, "a"); + ctx_, query, attribute_sizes, atts, [](unsigned a) { + return "a" + std::to_string(a); + }); }(attributes); // Submit query. @@ -2486,11 +2490,21 @@ void CSparseGlobalOrderFx::run(Instance instance) { // add fields to query [&](std::tuple dims) { query_applicator::set( - ctx_, query, dimension_sizes, dims, "d", outcursor); + ctx_, + query, + dimension_sizes, + dims, + [](unsigned d) { return "d" + std::to_string(d); }, + outcursor); }(outdims); [&](std::tuple atts) { query_applicator::set( - ctx_, query, attribute_sizes, atts, "a", outcursor); + ctx_, + query, + attribute_sizes, + atts, + [](unsigned a) { return "a" + std::to_string(a); }, + outcursor); }(outatts); rc = tiledb_query_submit(ctx_, query); diff --git a/test/support/src/array_templates.h b/test/support/src/array_templates.h index 752dab1cf85..daff34d8374 100644 --- a/test/support/src/array_templates.h +++ b/test/support/src/array_templates.h @@ -288,7 +288,7 @@ struct query_applicator { tiledb_query_t* query, auto& field_sizes, std::tuple fields, - const char* basename, + std::function fieldname, uint64_t cell_offset = 0) { auto set_data_buffer = [&](const std::string& name, auto& field, uint64_t& field_size) { @@ -304,9 +304,7 @@ struct query_applicator { [&](const auto&... field) { std::apply( [&](Us&... field_size) { - (set_data_buffer( - basename + std::to_string(d++), field, field_size), - ...); + (set_data_buffer(fieldname(d++), field, field_size), ...); }, field_sizes); }, From af81ad662225629bf5d4106b1b79e81611f440ec Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 6 Jan 2025 08:23:11 -0500 Subject: [PATCH 113/228] has_more_tiles() checks enabled_ --- tiledb/sm/query/readers/sparse_global_order_reader.cc | 5 ++--- tiledb/sm/query/readers/sparse_index_reader_base.h | 2 +- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index a5dbb45abce..c695e23e381 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -156,7 +156,7 @@ SparseGlobalOrderReader::SparseGlobalOrderReader( "sm.query.sparse_global_order.preprocess_tile_merge") .value_or(0); preprocess_tile_order_.cursor_ = 0; - preprocess_tile_order_.num_tiles_ = 0; // will be adjusted later if needed + preprocess_tile_order_.num_tiles_ = 1; // will be adjusted later if needed if (!preprocess_tile_order_.enabled_) { all_fragment_tile_order_.memory_used_for_coords_.resize( @@ -238,8 +238,7 @@ Status SparseGlobalOrderReader::dowork() { // (this happens after load_initial_data which identifies which tiles pass // subarray) std::optional preprocess_future; - if (preprocess_tile_order_.enabled_ && - preprocess_tile_order_.has_more_tiles() && + if (preprocess_tile_order_.has_more_tiles() && preprocess_tile_order_.tiles_.empty()) { preprocess_future.emplace(memory_used_for_coords_total_); preprocess_compute_result_tile_order(preprocess_future.value()); diff --git a/tiledb/sm/query/readers/sparse_index_reader_base.h b/tiledb/sm/query/readers/sparse_index_reader_base.h index 9be1617a835..83e49c58d15 100644 --- a/tiledb/sm/query/readers/sparse_index_reader_base.h +++ b/tiledb/sm/query/readers/sparse_index_reader_base.h @@ -310,7 +310,7 @@ struct PreprocessTileOrder { size_t num_tiles_; bool has_more_tiles() const { - return cursor_ < num_tiles_; + return enabled_ && cursor_ < num_tiles_; } }; From 8279a05c075318895b7d52ec5b6be682b38b3cc4 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 6 Jan 2025 08:24:56 -0500 Subject: [PATCH 114/228] Add AsserterRuntimeException --- test/support/assert_helpers.h | 39 ++++++++++++++++++++++++++--------- 1 file changed, 29 insertions(+), 10 deletions(-) diff --git a/test/support/assert_helpers.h b/test/support/assert_helpers.h index 5061a39ab58..e392f84704e 100644 --- a/test/support/assert_helpers.h +++ b/test/support/assert_helpers.h @@ -43,6 +43,8 @@ #include #include +#include + namespace tiledb::test { /** @@ -55,8 +57,16 @@ struct AsserterCatch {}; */ struct AsserterRapidcheck {}; +/** + * Marker that a template is instantiated by application code + */ +struct AsserterRuntimeException {}; + } // namespace tiledb::test +#define __STR_(x) #x +#define __STR_VA_(...) __STR_(__VA_ARGS__) + /** * Helper macro for running an assert in a context * where we might want to dispatch assertion failure behavior @@ -72,16 +82,25 @@ struct AsserterRapidcheck {}; * This expands to REQUIRE for `AsserterCatch` and RC_ASSERT for * `AsserterRapidcheck`. For both type markers this will throw an exception. */ -#define ASSERTER(...) \ - do { \ - static_assert( \ - std::is_same::value || \ - std::is_same::value); \ - if (std::is_same::value) { \ - REQUIRE(__VA_ARGS__); \ - } else { \ - RC_ASSERT(__VA_ARGS__); \ - } \ +#define ASSERTER(...) \ + do { \ + static_assert( \ + std::is_same::value || \ + std::is_same::value || \ + std::is_same:: \ + value); \ + if (std::is_same::value) { \ + REQUIRE(__VA_ARGS__); \ + } else if (std::is_same:: \ + value) { \ + RC_ASSERT(__VA_ARGS__); \ + } else { \ + if (!(__VA_ARGS__)) { \ + throw std::runtime_error( \ + std::string("Assertion failed: ") + \ + std::string(__STR_VA_(__VA_ARGS__))); \ + } \ + } \ } while (0) /** From f42e3a42cd342cefeec3f1fc2bedf667a8666e40 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 6 Jan 2025 08:25:52 -0500 Subject: [PATCH 115/228] query_applicator::set_field uses 0-based lambda arg --- test/src/unit-sparse-global-order-reader.cc | 8 ++++---- test/support/src/array_templates.h | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 01b9e2a6b75..1b8baa5a58f 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -605,7 +605,7 @@ void CSparseGlobalOrderFx::write_fragment(const Fragment& fragment) { [&](std::tuple dims) { query_applicator::set( ctx_, query, dimension_sizes, dims, [](unsigned d) { - return "d" + std::to_string(d); + return "d" + std::to_string(d + 1); }); }(dimensions); @@ -613,7 +613,7 @@ void CSparseGlobalOrderFx::write_fragment(const Fragment& fragment) { [&](std::tuple atts) { query_applicator::set( ctx_, query, attribute_sizes, atts, [](unsigned a) { - return "a" + std::to_string(a); + return "a" + std::to_string(a + 1); }); }(attributes); @@ -2494,7 +2494,7 @@ void CSparseGlobalOrderFx::run(Instance instance) { query, dimension_sizes, dims, - [](unsigned d) { return "d" + std::to_string(d); }, + [](unsigned d) { return "d" + std::to_string(d + 1); }, outcursor); }(outdims); [&](std::tuple atts) { @@ -2503,7 +2503,7 @@ void CSparseGlobalOrderFx::run(Instance instance) { query, attribute_sizes, atts, - [](unsigned a) { return "a" + std::to_string(a); }, + [](unsigned a) { return "a" + std::to_string(a + 1); }, outcursor); }(outatts); diff --git a/test/support/src/array_templates.h b/test/support/src/array_templates.h index daff34d8374..91adbc0ef66 100644 --- a/test/support/src/array_templates.h +++ b/test/support/src/array_templates.h @@ -299,7 +299,7 @@ struct query_applicator { ASSERTER("" == error_if_any(ctx, rc)); }; - uint64_t d = 1; + unsigned d = 0; std::apply( [&](const auto&... field) { std::apply( From d5f005e606ffe69ca8b1c2eef6c5398c3aee2716 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 6 Jan 2025 08:26:49 -0500 Subject: [PATCH 116/228] tiledb_submit_a_b --- test/CMakeLists.txt | 2 - test/performance/CMakeLists.txt | 25 ++ test/performance/tiledb_submit_a_b.cc | 242 ++++++++++++++++++++ test/src/unit-sparse-global-order-reader.cc | 189 --------------- 4 files changed, 267 insertions(+), 191 deletions(-) create mode 100644 test/performance/tiledb_submit_a_b.cc diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 0c95b3fdbf6..78124b5ec6e 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -379,9 +379,7 @@ endif() # CI tests add_subdirectory(ci) -if(WIN32) add_subdirectory(performance) -endif() add_custom_target( check-package diff --git a/test/performance/CMakeLists.txt b/test/performance/CMakeLists.txt index ec9c519ef32..efdc9ee5b8a 100644 --- a/test/performance/CMakeLists.txt +++ b/test/performance/CMakeLists.txt @@ -26,6 +26,8 @@ # THE SOFTWARE. # +if(WIN32) + # These options not exposed in bootstrap script. option(TILEDB_TESTS_AWS_S3_CONFIG "Use an S3 config appropriate for AWS in tests" OFF) @@ -94,3 +96,26 @@ if (${CMAKE_SYSTEM_NAME} MATCHES "Linux" AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU LINK_FLAGS "-Wl,--no-as-needed -ldl" ) endif() + +endif() + + +add_executable( + tiledb_submit_a_b EXCLUDE_FROM_ALL + $ + "tiledb_submit_a_b.cc" +) + +add_dependencies(tiledb_submit_a_b tiledb_test_support_lib) + +target_include_directories( + tiledb_submit_a_b BEFORE PRIVATE + ${TILEDB_CORE_INCLUDE_DIR} + ${TILEDB_EXPORT_HEADER_DIR} +) + +target_link_libraries(tiledb_submit_a_b + PUBLIC + TILEDB_CORE_OBJECTS_ILIB + tiledb_test_support_lib +) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc new file mode 100644 index 00000000000..44747e427c1 --- /dev/null +++ b/test/performance/tiledb_submit_a_b.cc @@ -0,0 +1,242 @@ +#include +#include +#include + +#include "tiledb/api/c_api/array/array_api_internal.h" +#include "tiledb/sm/array_schema/array_schema.h" +#include "tiledb/sm/array_schema/attribute.h" +#include "tiledb/sm/array_schema/dimension.h" +#include "tiledb/sm/stats/duration_instrument.h" + +#include +#include + +using namespace tiledb::test; +using namespace tiledb::test::templates; + +using Asserter = AsserterRuntimeException; + +/** + * Records durations as reported by `tiledb::sm::stats::DurationInstrument`. + */ +struct TimeKeeper { + std::map> durations; + + tiledb::sm::stats::DurationInstrument start_timer( + const std::string& stat) { + return tiledb::sm::stats::DurationInstrument(*this, stat); + } + + void report_duration( + const std::string& stat, const std::chrono::duration duration) { + durations[stat].push_back(duration.count()); + } + + /** + * Write durations to a file for analysis. + */ + void dump_durations(const char* path) const { + std::ofstream dump(path); + + for (const auto& stat : durations) { + dump << stat.first << " = ["; + + bool is_first = true; + for (const auto& duration : stat.second) { + if (!is_first) { + dump << ", "; + } else { + is_first = false; + } + dump << duration; + } + + dump << "]" << std::endl << std::endl; + } + } +}; + +template +static void run( + TimeKeeper& time_keeper, + const char* array_uri, + tiledb_config_t* a_config, + tiledb_config_t* b_config) { + tiledb::test::SparseGlobalOrderReaderMemoryBudget memory; + memory.total_budget_ = std::to_string(1024 * 1024 * 1024); + memory.ratio_tile_ranges_ = "0.01"; + + const uint64_t num_user_cells = 1024 * 1024; + + Fragment a; + Fragment b; + + auto reset = [num_user_cells](Fragment& buf) { + std::apply( + [&](auto&... outfield) { (outfield.resize(num_user_cells), ...); }, + std::tuple_cat(buf.dimensions(), buf.attributes())); + }; + reset(a); + reset(b); + + tiledb_config_t* config; + { + tiledb_error_t* error = nullptr; + ASSERTER(tiledb_config_alloc(&config, &error) == TILEDB_OK); + } + memory.apply(config); + + tiledb_ctx_t* ctx; + ASSERTER(tiledb_ctx_alloc(config, &ctx) == TILEDB_OK); + + tiledb_config_free(&config); + + // Open array for reading. + CApiArray array(ctx, array_uri, TILEDB_READ); + + auto dimension_name = [&](unsigned d) -> std::string { + return std::string( + array->array_schema_latest().domain().dimension_ptr(d)->name()); + }; + auto attribute_name = [&](unsigned a) -> std::string { + return std::string(array->array_schema_latest().attribute(a)->name()); + }; + + // Create query which does NOT do merge + tiledb_query_t* a_query; + TRY(ctx, tiledb_query_alloc(ctx, array, TILEDB_READ, &a_query)); + TRY(ctx, tiledb_query_set_layout(ctx, a_query, TILEDB_GLOBAL_ORDER)); + TRY(ctx, tiledb_query_set_config(ctx, a_query, a_config)); + + // Create query which DOES do merge + tiledb_query_t* b_query; + TRY(ctx, tiledb_query_alloc(ctx, array, TILEDB_READ, &b_query)); + TRY(ctx, tiledb_query_set_layout(ctx, b_query, TILEDB_GLOBAL_ORDER)); + TRY(ctx, tiledb_query_set_config(ctx, b_query, b_config)); + + // helper to do basic checks on both + auto do_submit = [&](auto& key, auto& query, auto& outdata) -> uint64_t { + // make field size locations + auto dimension_sizes = [](std::tuple dimensions) { + return query_applicator::make_field_sizes(dimensions); + }(outdata.dimensions()); + auto attribute_sizes = [](std::tuple attributes) { + return query_applicator::make_field_sizes(attributes); + }(outdata.attributes()); + + // add fields to query + [&](std::tuple dims) { + query_applicator::set( + ctx, query, dimension_sizes, dims, dimension_name); + }(outdata.dimensions()); + [&](std::tuple atts) { + query_applicator::set( + ctx, query, attribute_sizes, atts, attribute_name); + }(outdata.attributes()); + + { + tiledb::sm::stats::DurationInstrument qtimer = + time_keeper.start_timer(key); + TRY(ctx, tiledb_query_submit(ctx, query)); + } + + tiledb_query_status_t status; + TRY(ctx, tiledb_query_get_status(ctx, query, &status)); + + const uint64_t dim_num_cells = [&](auto dims) { + return query_applicator::num_cells( + dims, dimension_sizes); + }(outdata.dimensions()); + const uint64_t att_num_cells = [&](auto atts) { + return query_applicator::num_cells( + atts, attribute_sizes); + }(outdata.attributes()); + + ASSERTER(dim_num_cells == att_num_cells); + + if (dim_num_cells < outdata.size()) { + ASSERTER(status == TILEDB_COMPLETED); + } + + return dim_num_cells; + }; + + const std::string a_key = std::string(array_uri) + ".a"; + const std::string b_key = std::string(array_uri) + ".b"; + + while (true) { + const uint64_t a_num_cells = do_submit(a_key, a_query, a); + const uint64_t on_num_cells = do_submit(b_key, b_query, b); + + ASSERTER(a_num_cells == on_num_cells); + + std::apply( + [&](auto&... outfield) { (outfield.resize(a_num_cells), ...); }, + std::tuple_cat(a.dimensions(), a.attributes())); + std::apply( + [&](auto&... outfield) { (outfield.resize(on_num_cells), ...); }, + std::tuple_cat(b.dimensions(), b.attributes())); + + ASSERTER(a.dimensions() == b.dimensions()); + + // NB: this is only correct if there are no duplicate coordinates, + // in which case we need to adapt what CSparseGlobalOrderFx::run does + ASSERTER(a.attributes() == b.attributes()); + + reset(a); + reset(b); + + if (a_num_cells < num_user_cells) { + break; + } + } +} + +using Fragment = Fragment2D; + +/** + * Runs sparse global order reader on a 2D array + * with two `int64_t` dimensions and a `float` attribute. + * This schema is common in SOMA, comparing the results + * from "preprocess merge off" and "preprocess merge on". + * + * The time of each `tiledb_query_submit` is recorded + * for both variations, and then dumped to `/tmp/time_keeper.out` + * when the test is completed. + */ +int main(int argc, char** argv) { + tiledb_error_t* error; + + tiledb_config_t* a_conf; + RETURN_IF_ERR(tiledb_config_alloc(&a_conf, &error)); + RETURN_IF_ERR(tiledb_config_set( + a_conf, + "sm.query.sparse_global_order.preprocess_tile_merge", + "0", + &error)); + + tiledb_config_t* b_conf; + RETURN_IF_ERR(tiledb_config_alloc(&b_conf, &error)); + RETURN_IF_ERR(tiledb_config_set( + b_conf, + "sm.query.sparse_global_order.preprocess_tile_merge", + "128", + &error)); + + TimeKeeper time_keeper; + + std::span array_uris( + static_cast(&argv[1]), argc - 1); + + for (const auto& array_uri : array_uris) { + run(time_keeper, array_uri, a_conf, b_conf); + } + + tiledb_config_free(&b_conf); + tiledb_config_free(&a_conf); + + time_keeper.dump_durations("/tmp/time_keeper.out"); + + return 0; +} + diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 1b8baa5a58f..931a206a50d 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -45,7 +45,6 @@ #include "tiledb/sm/misc/types.h" #include "tiledb/sm/query/readers/result_tile.h" #include "tiledb/sm/query/readers/sparse_global_order_reader.h" -#include "tiledb/sm/stats/duration_instrument.h" #ifdef _WIN32 #include "tiledb/sm/filesystem/win.h" @@ -2949,191 +2948,3 @@ TEST_CASE_METHOD( std::string::npos); } -/** - * Records durations as reported by `tiledb::sm::stats::DurationInstrument`. - */ -struct TimeKeeper { - std::map> durations; - - tiledb::sm::stats::DurationInstrument start_timer( - const std::string& stat) { - return tiledb::sm::stats::DurationInstrument(*this, stat); - } - - void report_duration( - const std::string& stat, const std::chrono::duration duration) { - durations[stat].push_back(duration.count()); - } - - /** - * Write durations to a file for analysis. - */ - void dump_durations(const char* path) const { - std::ofstream dump(path); - - for (const auto& stat : durations) { - dump << stat.first << " = ["; - - bool is_first = true; - for (const auto& duration : stat.second) { - if (!is_first) { - dump << ", "; - } else { - is_first = false; - } - dump << duration; - } - - dump << "]" << std::endl << std::endl; - } - } -}; - -/** - * Runs sparse global order reader on a 2D array - * with two `int64_t` dimensions and a `float` attribute. - * This schema is common in SOMA, comparing the results - * from "preprocess merge off" and "preprocess merge on". - * - * The time of each `tiledb_query_submit` is recorded - * for both variations, and then dumped to `/tmp/time_keeper.out` - * when the test is completed. - */ -TEST_CASE_METHOD( - CSparseGlobalOrderFx, - "Sparse global order reader: benchmark compare", - "[sparse-global-order][.]") { - using Asserter = tiledb::test::AsserterCatch; - - const char* array_uri = - "s3://tiledb-johnkerl/s/v/tabula-sapiens-immune/ms/RNA/X/data"; - - memory_.total_budget_ = std::to_string(1024 * 1024 * 1024); - memory_.ratio_tile_ranges_ = "0.01"; - update_config(); - - const uint64_t num_user_cells = 1024 * 1024; - - std::vector offdim0(num_user_cells); - std::vector offdim1(num_user_cells); - std::vector offdata(num_user_cells); - std::vector ondim0(num_user_cells); - std::vector ondim1(num_user_cells); - std::vector ondata(num_user_cells); - - // Open array for reading. - CApiArray array(ctx_, array_uri, TILEDB_READ); - - // Create query which does NOT do merge - tiledb_query_t* off_query; - auto rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &off_query); - RCCATCH_REQUIRE("" == error_if_any(rc)); - rc = tiledb_query_set_layout(ctx_, off_query, TILEDB_GLOBAL_ORDER); - RCCATCH_REQUIRE("" == error_if_any(rc)); - - // Create query which DOES do merge - tiledb_query_t* on_query; - rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &on_query); - RCCATCH_REQUIRE("" == error_if_any(rc)); - rc = tiledb_query_set_layout(ctx_, on_query, TILEDB_GLOBAL_ORDER); - RCCATCH_REQUIRE("" == error_if_any(rc)); - { - tiledb_config_t* qconfig; - tiledb_error_t* error = nullptr; - RCCATCH_REQUIRE(tiledb_config_alloc(&qconfig, &error) == TILEDB_OK); - RCCATCH_REQUIRE(error == nullptr); - rc = tiledb_config_set( - qconfig, - "sm.query.sparse_global_order.preprocess_tile_merge", - "128", - &error); - RCCATCH_REQUIRE("" == error_if_any(rc)); - rc = tiledb_query_set_config(ctx_, on_query, qconfig); - RCCATCH_REQUIRE("" == error_if_any(rc)); - tiledb_config_free(&qconfig); - } - - TimeKeeper time_keeper; - - // helper to do basic checks on both - auto do_submit = [&](auto& key, - auto& query, - auto& outdim0, - auto& outdim1, - auto& outdata) -> uint64_t { - uint64_t outdim0_size = outdim0.size() * sizeof(int64_t); - uint64_t outdim1_size = outdim1.size() * sizeof(int64_t); - uint64_t outdata_size = outdata.size() * sizeof(float); - - rc = tiledb_query_set_data_buffer( - ctx_, query, "soma_dim_0", &outdim0[0], &outdim0_size); - RCCATCH_REQUIRE("" == error_if_any(rc)); - rc = tiledb_query_set_data_buffer( - ctx_, query, "soma_dim_1", &outdim1[0], &outdim1_size); - RCCATCH_REQUIRE("" == error_if_any(rc)); - rc = tiledb_query_set_data_buffer( - ctx_, query, "soma_data", &outdata[0], &outdata_size); - RCCATCH_REQUIRE("" == error_if_any(rc)); - - { - tiledb::sm::stats::DurationInstrument qtimer = - time_keeper.start_timer(key); - rc = tiledb_query_submit(ctx_, query); - RCCATCH_REQUIRE("" == error_if_any(rc)); - } - - tiledb_query_status_t status; - rc = tiledb_query_get_status(ctx_, query, &status); - RCCATCH_REQUIRE("" == error_if_any(rc)); - - RCCATCH_REQUIRE(outdim0_size % sizeof(int64_t) == 0); - RCCATCH_REQUIRE(outdim1_size % sizeof(int64_t) == 0); - RCCATCH_REQUIRE(outdata_size % sizeof(float) == 0); - - const uint64_t num_dim0 = outdim0_size / sizeof(int64_t); - const uint64_t num_dim1 = outdim1_size / sizeof(int64_t); - const uint64_t num_data = outdata_size / sizeof(float); - - RCCATCH_REQUIRE(num_dim0 == num_dim1); - RCCATCH_REQUIRE(num_dim0 == num_data); - - if (num_dim0 < outdim0.size()) { - RCCATCH_REQUIRE(status == TILEDB_COMPLETED); - } - - return num_dim0; - }; - - while (true) { - const uint64_t off_num_cells = - do_submit("off", off_query, offdim0, offdim1, offdata); - const uint64_t on_num_cells = - do_submit("on", on_query, ondim0, ondim1, ondata); - - RCCATCH_REQUIRE(off_num_cells == on_num_cells); - - offdim0.resize(off_num_cells); - offdim1.resize(off_num_cells); - offdata.resize(off_num_cells); - ondim0.resize(on_num_cells); - ondim1.resize(on_num_cells); - ondata.resize(on_num_cells); - - RCCATCH_REQUIRE(offdim0 == ondim0); - RCCATCH_REQUIRE(offdim1 == ondim1); - RCCATCH_REQUIRE(offdata == ondata); - - offdim0.resize(num_user_cells); - offdim1.resize(num_user_cells); - offdata.resize(num_user_cells); - ondim0.resize(num_user_cells); - ondim1.resize(num_user_cells); - ondata.resize(num_user_cells); - - if (off_num_cells < num_user_cells) { - break; - } - } - - time_keeper.dump_durations("/tmp/time_keeper.out"); -} From 6b8a166b7dbdfb3595bd8fdb2cf1d3afd52f471a Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 6 Jan 2025 09:39:37 -0500 Subject: [PATCH 117/228] tiledb_submit_a_b load config from json --- test/performance/tiledb_submit_a_b.cc | 50 ++++++++++++++++++--------- 1 file changed, 33 insertions(+), 17 deletions(-) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 44747e427c1..03a3e37fcce 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -8,6 +8,8 @@ #include "tiledb/sm/array_schema/dimension.h" #include "tiledb/sm/stats/duration_instrument.h" +#include "external/include/nlohmann/json.hpp" + #include #include @@ -16,6 +18,8 @@ using namespace tiledb::test::templates; using Asserter = AsserterRuntimeException; +using json = nlohmann::json; + /** * Records durations as reported by `tiledb::sm::stats::DurationInstrument`. */ @@ -194,6 +198,20 @@ static void run( using Fragment = Fragment2D; +capi_return_t json2config(tiledb_config_t** config, const json& j) { + tiledb_error_t* error; + RETURN_IF_ERR(tiledb_config_alloc(config, &error)); + const json jconf = j["config"]; + for (auto it = jconf.begin(); it != jconf.end(); ++it) { + const auto key = it.key(); + const auto value = nlohmann::to_string(it.value()); + RETURN_IF_ERR( + tiledb_config_set(*config, key.c_str(), value.c_str(), &error)); + } + + return TILEDB_OK; +} + /** * Runs sparse global order reader on a 2D array * with two `int64_t` dimensions and a `float` attribute. @@ -205,28 +223,26 @@ using Fragment = Fragment2D; * when the test is completed. */ int main(int argc, char** argv) { - tiledb_error_t* error; + json config; + { + std::ifstream configfile(argv[1]); + if (configfile.fail()) { + std::cerr << "Error opening config file: " << argv[1] << std::endl; + return -1; + } + config = json::parse( + std::istreambuf_iterator(configfile), + std::istreambuf_iterator()); + } - tiledb_config_t* a_conf; - RETURN_IF_ERR(tiledb_config_alloc(&a_conf, &error)); - RETURN_IF_ERR(tiledb_config_set( - a_conf, - "sm.query.sparse_global_order.preprocess_tile_merge", - "0", - &error)); - - tiledb_config_t* b_conf; - RETURN_IF_ERR(tiledb_config_alloc(&b_conf, &error)); - RETURN_IF_ERR(tiledb_config_set( - b_conf, - "sm.query.sparse_global_order.preprocess_tile_merge", - "128", - &error)); + tiledb_config_t *a_conf, *b_conf; + RETURN_IF_ERR(json2config(&a_conf, config["a"])); + RETURN_IF_ERR(json2config(&b_conf, config["b"])); TimeKeeper time_keeper; std::span array_uris( - static_cast(&argv[1]), argc - 1); + static_cast(&argv[2]), argc - 2); for (const auto& array_uri : array_uris) { run(time_keeper, array_uri, a_conf, b_conf); From 022eb0bb541bdbbc13efab55d86f79dc9faec06c Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 6 Jan 2025 11:23:40 -0500 Subject: [PATCH 118/228] Fix num_tiles in can_complete_in_memory_budget --- test/src/unit-sparse-global-order-reader.cc | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 931a206a50d..ffc3d23eeb1 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -870,11 +870,6 @@ static bool can_complete_in_memory_budget( const auto& fragment_metadata = array->array()->fragment_metadata(); - uint64_t num_tiles = 0; - for (const auto& fragment : fragment_metadata) { - num_tiles += fragment->tile_num(); - } - for (const auto& fragment : fragment_metadata) { const_cast(fragment.get()) ->loaded_metadata() @@ -959,6 +954,7 @@ static bool can_complete_in_memory_budget( * Iterate through the tiles in the same order that the sparse * reader would process them in, tracking memory usage as we go. */ + const uint64_t num_tiles = mbr_lower_bound.size(); uint64_t active_tile_size = sizeof(RT) * num_tiles; uint64_t next_tile_size = 0; while (active_tile_size + next_tile_size < coords_budget && From d4d86ec181ff9e1167c4c30d295c27fdb1ccb59d Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 6 Jan 2025 13:18:21 -0500 Subject: [PATCH 119/228] Fix make_extent --- test/support/rapidcheck/array_templates.h | 35 ++++++++++++++++++----- 1 file changed, 28 insertions(+), 7 deletions(-) diff --git a/test/support/rapidcheck/array_templates.h b/test/support/rapidcheck/array_templates.h index 2eee43a251b..064e8d29937 100644 --- a/test/support/rapidcheck/array_templates.h +++ b/test/support/rapidcheck/array_templates.h @@ -67,6 +67,24 @@ struct Arbitrary> { } }; +/** + * @return `a - b` if it does not overflow, `std::nullopt` if it does + */ +template +std::optional checked_sub(T a, T b) { + if (!std::is_signed::value) { + return (b > a ? std::nullopt : std::optional(a - b)); + } else if (b < 0) { + return ( + std::numeric_limits::max() + b < a ? std::nullopt : + std::optional(a - b)); + } else { + return ( + std::numeric_limits::min() - b > a ? std::nullopt : + std::optional(a - b)); + } +} + template Gen make_extent(const Domain& domain) { // upper bound on all possible extents to avoid unreasonably @@ -85,12 +103,15 @@ Gen make_extent(const Domain& domain) { D extent_lower_bound = 1; D extent_upper_bound; - if (domain.lower_bound + domain.upper_bound + 1 < domain.lower_bound) { - // overflow - extent_upper_bound = extent_limit; - } else { + + const auto bound_distance = + checked_sub(domain.upper_bound, domain.lower_bound); + if (bound_distance.has_value()) { extent_upper_bound = - std::min(extent_limit, domain.lower_bound + domain.upper_bound + 1); + (bound_distance.value() < extent_limit ? bound_distance.value() + 1 : + extent_limit); + } else { + extent_upper_bound = extent_limit; } return gen::inRange(extent_lower_bound, extent_upper_bound + 1); @@ -118,14 +139,14 @@ Gen make_coordinate(const Domain& domain) { // As a result some contortion is required to deal // with numeric_limits. if (std::is_signed::value) { - if (domain.upper_bound < std::numeric_limits::max()) { + if (int64_t(domain.upper_bound) < std::numeric_limits::max()) { return gen::cast(gen::inRange( int64_t(domain.lower_bound), int64_t(domain.upper_bound + 1))); } else { return gen::inRange(domain.lower_bound, domain.upper_bound); } } else { - if (domain.upper_bound < std::numeric_limits::max()) { + if (uint64_t(domain.upper_bound) < std::numeric_limits::max()) { return gen::cast(gen::inRange( uint64_t(domain.lower_bound), uint64_t(domain.upper_bound + 1))); } else { From f3b7340a75219fa48703df36ae3ba9edf1ec7777 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 6 Jan 2025 14:05:59 -0500 Subject: [PATCH 120/228] Remove commented-out code --- test/src/unit-sparse-global-order-reader.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index ffc3d23eeb1..5ae943aab5e 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -1439,7 +1439,6 @@ TEST_CASE_METHOD( rc::prop("rapidcheck many overlapping fragments", [doit]() { const size_t num_fragments = *rc::gen::inRange(10, 24); const size_t fragment_size = *rc::gen::inRange(2, 200 - 64); - // const size_t num_user_cells = *rc::gen::inRange(1, 1024 * 1024); const size_t num_user_cells = 1024; const auto subarray = *rc::make_subarray_1d(templates::Domain(1, 200)); From 3437bf744c671eb1e94b4c0231f3e7d8783e516c Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 6 Jan 2025 14:09:11 -0500 Subject: [PATCH 121/228] Fix formatting --- test/performance/tiledb_submit_a_b.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 03a3e37fcce..58c8fa363ff 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -255,4 +255,3 @@ int main(int argc, char** argv) { return 0; } - From 80694e357d0d2d628c82ddeb1162e629c532b4b0 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 6 Jan 2025 14:39:53 -0500 Subject: [PATCH 122/228] tiledb_submit_a_b subarray scratch --- test/performance/tiledb_submit_a_b.cc | 54 +++++++++++++++++++++++++-- 1 file changed, 51 insertions(+), 3 deletions(-) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 58c8fa363ff..342c033751d 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -60,17 +60,63 @@ struct TimeKeeper { } }; +capi_return_t json2query( + tiledb_ctx_t* ctx, + tiledb_array_t* array, + tiledb_query_t* query, + const json& jq) { + if (jq.find("subarray") != jq.end()) { + tiledb_subarray_t* subarray; + RETURN_IF_ERR(tiledb_subarray_alloc(ctx, array, &subarray)); + + tiledb_array_schema_t* schema; + RETURN_IF_ERR(tiledb_array_get_schema(ctx, array, &schema)); + + tiledb_domain_t* domain; + RETURN_IF_ERR(tiledb_array_schema_get_domain(ctx, schema, &domain)); + + int d = 0; + const auto& jsub = jq["subarray"]; + for (const auto& jdim : jsub) { + if (jdim.find("%") != jdim.end()) { + const int percent = jdim["%"].get(); + + // FIXME: make generic + int is_empty; + int64_t domain[2]; + RETURN_IF_ERR(tiledb_array_get_non_empty_domain_from_index( + ctx, array, d, &domain[0], &is_empty)); + if (is_empty) { + continue; + } + + const auto span = (domain[1] - domain[0] + 1); + domain[0] += ((span * (100 - percent)) / 100) / 2; + domain[1] -= ((span * (100 - percent)) / 100) / 2; + + RETURN_IF_ERR(tiledb_subarray_add_range( + ctx, subarray, d, &domain[0], &domain[1], 0)); + } + } + + tiledb_query_set_subarray_t(ctx, query, subarray); + } + + return TILEDB_OK; +} + template static void run( TimeKeeper& time_keeper, const char* array_uri, + const json& query_config, tiledb_config_t* a_config, tiledb_config_t* b_config) { tiledb::test::SparseGlobalOrderReaderMemoryBudget memory; memory.total_budget_ = std::to_string(1024 * 1024 * 1024); memory.ratio_tile_ranges_ = "0.01"; - const uint64_t num_user_cells = 1024 * 1024; + const uint64_t num_user_cells = 1024 * 1024 * 128; Fragment a; Fragment b; @@ -111,12 +157,14 @@ static void run( TRY(ctx, tiledb_query_alloc(ctx, array, TILEDB_READ, &a_query)); TRY(ctx, tiledb_query_set_layout(ctx, a_query, TILEDB_GLOBAL_ORDER)); TRY(ctx, tiledb_query_set_config(ctx, a_query, a_config)); + json2query(ctx, array, a_query, query_config); // Create query which DOES do merge tiledb_query_t* b_query; TRY(ctx, tiledb_query_alloc(ctx, array, TILEDB_READ, &b_query)); TRY(ctx, tiledb_query_set_layout(ctx, b_query, TILEDB_GLOBAL_ORDER)); TRY(ctx, tiledb_query_set_config(ctx, b_query, b_config)); + json2query(ctx, array, b_query, query_config); // helper to do basic checks on both auto do_submit = [&](auto& key, auto& query, auto& outdata) -> uint64_t { @@ -196,7 +244,7 @@ static void run( } } -using Fragment = Fragment2D; +using Fragment = Fragment2D; capi_return_t json2config(tiledb_config_t** config, const json& j) { tiledb_error_t* error; @@ -245,7 +293,7 @@ int main(int argc, char** argv) { static_cast(&argv[2]), argc - 2); for (const auto& array_uri : array_uris) { - run(time_keeper, array_uri, a_conf, b_conf); + run(time_keeper, array_uri, config["query"], a_conf, b_conf); } tiledb_config_free(&b_conf); From b80fe819af1676693784080bd865d5ee8a18d0d1 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 6 Jan 2025 14:40:36 -0500 Subject: [PATCH 123/228] make format --- test/src/unit-sparse-global-order-reader.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 5ae943aab5e..dabb28bd2de 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2942,4 +2942,3 @@ TEST_CASE_METHOD( "Multi-range reads are not supported on a global order query") != std::string::npos); } - From 2787ba2b835a6092792206a7a7e4e1ab124674f8 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 6 Jan 2025 15:36:17 -0500 Subject: [PATCH 124/228] override in SparseGlobalOrderReader decls --- .../sm/query/readers/sparse_global_order_reader.h | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index d198a9d5edf..df6cf7ee9fa 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -99,7 +99,7 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, * * @return Status. */ - Status finalize() { + Status finalize() override { return Status::Ok(); } @@ -108,32 +108,32 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, * * @return The query status. */ - bool incomplete() const; + bool incomplete() const override; /** * Returns `true` if the query was incomplete. * * @return The query status. */ - QueryStatusDetailsReason status_incomplete_reason() const; + QueryStatusDetailsReason status_incomplete_reason() const override; /** * Initialize the memory budget variables. */ - void refresh_config(); + void refresh_config() override; /** * Performs a read query using its set members. * * @return Status. */ - Status dowork(); + Status dowork() override; /** Resets the reader object. */ - void reset(); + void reset() override; /** Returns the name of the strategy */ - std::string name(); + std::string name() override; /** Used in deserialization */ virtual void set_preprocess_tile_order_cursor( From a808c54b877c27db809886fa9bd9c1e58bd0f852 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 6 Jan 2025 15:36:29 -0500 Subject: [PATCH 125/228] #include for std::clamp --- tiledb/common/algorithm/parallel_merge.h | 1 + 1 file changed, 1 insertion(+) diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h index fc74555c6f2..a7e0843d916 100644 --- a/tiledb/common/algorithm/parallel_merge.h +++ b/tiledb/common/algorithm/parallel_merge.h @@ -97,6 +97,7 @@ #include "tiledb/common/thread_pool/producer_consumer_queue.h" #include "tiledb/common/thread_pool/thread_pool.h" +#include #include #include From fc42e28a8c4c6d0955d841f582d4bbbfaab15f9d Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 6 Jan 2025 15:36:55 -0500 Subject: [PATCH 126/228] Fix unit-sparse-global-order-reader.cc warnings hopefully --- test/src/unit-sparse-global-order-reader.cc | 63 +++++++++++---------- 1 file changed, 32 insertions(+), 31 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index dabb28bd2de..70eddb0a906 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -82,22 +82,22 @@ Gen>> make_subarray_1d( * Options for configuring the CSparseGlobalFx default 1D array */ struct DefaultArray1DConfig { - uint64_t capacity; - bool allow_dups; + uint64_t capacity_; + bool allow_dups_; - templates::Dimension dimension; + templates::Dimension dimension_; DefaultArray1DConfig() - : capacity(2) - , allow_dups(false) { - dimension.domain.lower_bound = 1; - dimension.domain.upper_bound = 200; - dimension.extent = 2; + : capacity_(2) + , allow_dups_(false) { + dimension_.domain.lower_bound = 1; + dimension_.domain.upper_bound = 200; + dimension_.extent = 2; } DefaultArray1DConfig with_allow_dups(bool allow_dups) const { auto copy = *this; - copy.allow_dups = allow_dups; + copy.allow_dups_ = allow_dups; return copy; } }; @@ -119,11 +119,11 @@ struct FxRun1D { SparseGlobalOrderReaderMemoryBudget memory; uint64_t tile_capacity() const { - return array.capacity; + return array.capacity_; } bool allow_duplicates() const { - return array.allow_dups; + return array.allow_dups_; } /** @@ -190,7 +190,7 @@ struct FxRun1D { std::tuple&> dimensions() const { return std::tuple&>( - array.dimension); + array.dimension_); } std::tuple attributes() const { @@ -516,16 +516,16 @@ void CSparseGlobalOrderFx::create_default_array_1d( TILEDB_SPARSE, {"d"}, {TILEDB_INT32}, - std::vector{(void*)(&config.dimension.domain.lower_bound)}, - std::vector{(void*)(&config.dimension.extent)}, + std::vector{(void*)(&config.dimension_.domain.lower_bound)}, + std::vector{(void*)(&config.dimension_.extent)}, {"a"}, {TILEDB_INT32}, {1}, {tiledb::test::Compressor(TILEDB_FILTER_NONE, -1)}, TILEDB_ROW_MAJOR, TILEDB_ROW_MAJOR, - config.capacity, - config.allow_dups); + config.capacity_, + config.allow_dups_); } void CSparseGlobalOrderFx::create_default_array_1d_strings(bool allow_dups) { @@ -1242,7 +1242,7 @@ TEST_CASE_METHOD( fragment1.dim_.resize(fragment0.dim_.size()); for (size_t i = 0; i < fragment1.dim_.size(); i++) { fragment1.dim_[i] = - static_cast(i / 10) + (fragment0.dim_.size() / 2); + static_cast((i / 10) + (fragment0.dim_.size() / 2)); } // atts are whatever @@ -1259,8 +1259,8 @@ TEST_CASE_METHOD( instance.fragments.push_back(fragment1); instance.num_user_cells = num_user_cells; - instance.array.dimension.extent = extent; - instance.array.allow_dups = true; + instance.array.dimension_.extent = extent; + instance.array.allow_dups_ = true; instance.memory.total_budget_ = "20000"; instance.memory.ratio_array_data_ = "0.5"; @@ -1339,7 +1339,7 @@ TEST_CASE_METHOD( instance.subarray = subarray; instance.memory.total_budget_ = "20000"; instance.memory.ratio_array_data_ = "0.5"; - instance.array.allow_dups = true; + instance.array.allow_dups_ = true; run(instance); }; @@ -1402,9 +1402,9 @@ TEST_CASE_METHOD( const double ratio_coords = 0.2; FxRun1D instance; - instance.array.capacity = num_fragments * 2; - instance.array.dimension.extent = num_fragments * 2; - instance.array.allow_dups = true; + instance.array.capacity_ = num_fragments * 2; + instance.array.dimension_.extent = num_fragments * 2; + instance.array.allow_dups_ = true; instance.subarray = subarray; instance.memory.total_budget_ = std::to_string(total_budget); @@ -1417,7 +1417,7 @@ TEST_CASE_METHOD( std::iota( fragment.dim_.begin(), fragment.dim_.end(), - instance.array.dimension.domain.lower_bound + f); + instance.array.dimension_.domain.lower_bound + f); auto& atts = std::get<0>(fragment.atts_); atts.resize(fragment_size); @@ -2659,11 +2659,12 @@ struct Arbitrary { int num_user_cells) { FxRun1D instance; std::tie( - instance.array.dimension, instance.subarray, instance.fragments) = - fragments; + instance.array.dimension_, + instance.subarray, + instance.fragments) = fragments; instance.num_user_cells = num_user_cells; - instance.array.allow_dups = true; + instance.array.allow_dups_ = true; return instance; }, @@ -2779,11 +2780,11 @@ void show(const FxRun1D& instance, std::ostream& os) { os << "\t]," << std::endl; os << "\t\"num_user_cells\": " << instance.num_user_cells << std::endl; os << "\t\"array\": {" << std::endl; - os << "\t\t\"allow_dups\": " << instance.array.allow_dups << std::endl; - os << "\t\t\"domain\": [" << instance.array.dimension.domain.lower_bound - << ", " << instance.array.dimension.domain.upper_bound << "]," + os << "\t\t\"allow_dups\": " << instance.array.allow_dups_ << std::endl; + os << "\t\t\"domain\": [" << instance.array.dimension_.domain.lower_bound + << ", " << instance.array.dimension_.domain.upper_bound << "]," << std::endl; - os << "\t\t\"extent\": " << instance.array.dimension.extent << std::endl; + os << "\t\t\"extent\": " << instance.array.dimension_.extent << std::endl; os << "\t}," << std::endl; os << "\t\"memory\": {" << std::endl; os << "\t\t\"total_budget\": " << instance.memory.total_budget_ << ", " From 3c4fc5d662d0461581c1f7fba904756abe787079 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 6 Jan 2025 16:16:57 -0500 Subject: [PATCH 127/228] Fix non-gcc compiler issues --- test/src/unit-sparse-global-order-reader.cc | 3 ++- tiledb/common/algorithm/test/unit_parallel_merge.cc | 6 +++--- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 70eddb0a906..89fbbc0eceb 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -57,6 +57,7 @@ #include +#include #include #include @@ -1314,7 +1315,7 @@ TEST_CASE_METHOD( fragment0.dim_.resize(fragment_size); fragment0.dim_[0] = 1; for (size_t i = 1; i < fragment0.dim_.size(); i++) { - fragment0.dim_[i] = 1 + 2 * ((i + 1) / 2); + fragment0.dim_[i] = static_cast(1 + 2 * ((i + 1) / 2)); } // Write a fragment F1 with tiles [2,4][4,6][6,8][8,10]... diff --git a/tiledb/common/algorithm/test/unit_parallel_merge.cc b/tiledb/common/algorithm/test/unit_parallel_merge.cc index 69a392e8d29..8731f4659a8 100644 --- a/tiledb/common/algorithm/test/unit_parallel_merge.cc +++ b/tiledb/common/algorithm/test/unit_parallel_merge.cc @@ -372,7 +372,7 @@ struct Arbitrary> { } } } - return VerifySplitPointStream{ + return VerifySplitPointStream{ .memory = memory_tracker, .streams = streams, .which = which, @@ -399,7 +399,7 @@ struct Arbitrary> { gen::just(streams), gen::inRange(1, total_items + 1)); }); return gen::map(fields, [](std::pair, uint64_t> fields) { - return VerifyIdentifyMergeUnit{ + return VerifyIdentifyMergeUnit{ .streams = fields.first, .target_items = fields.second}; }); } @@ -431,7 +431,7 @@ struct Arbitrary> { [](Streams streams, ParallelMergeOptions options, size_t pool_concurrency) { - return VerifyParallelMerge{ + return VerifyParallelMerge{ .streams = streams, .options = options, .pool_concurrency = pool_concurrency}; From 0d767bd36106d999d329585b82828b1a7e473bec Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 6 Jan 2025 17:15:00 -0500 Subject: [PATCH 128/228] Use concept to make parallel merge much more interface friendly --- tiledb/common/algorithm/parallel_merge.h | 83 ++++++++++++------- .../algorithm/test/unit_parallel_merge.cc | 62 +++++++------- .../readers/sparse_global_order_reader.cc | 13 +-- 3 files changed, 86 insertions(+), 72 deletions(-) diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h index a7e0843d916..7a4d3c19a51 100644 --- a/tiledb/common/algorithm/parallel_merge.h +++ b/tiledb/common/algorithm/parallel_merge.h @@ -100,6 +100,7 @@ #include #include #include +#include namespace tiledb::algorithm { @@ -110,6 +111,20 @@ class ParallelMergeException : public tiledb::common::StatusException { } }; +/** + * Description of data which can be parallel-merged, + * which is any random-access collection of contiguous items + * (e.g. `std::vector>` for some `T`). + */ +template +concept ParallelMergeable = requires(const I& spans, size_t idx) { + typename I::value_type::value_type; + { spans.size() } -> std::convertible_to; + { + spans[idx] + } -> std::convertible_to>; +}; + /** * Options for running the parallel merge. */ @@ -194,16 +209,18 @@ struct ParallelMergeFuture { // index of the next expected item in `merge_bounds_` uint64_t merge_cursor_; - template + template friend class ParallelMerge; }; -template > +template < + ParallelMergeable I, + class Compare = std::less> tdb::pmr::unique_ptr parallel_merge( tiledb::common::ThreadPool& pool, const ParallelMergeOptions& options, - std::span> streams, - T* output); + const I& streams, + std::remove_cv_t* output); /** * Represents one sequential unit of the parallel merge. @@ -267,22 +284,25 @@ struct VerifyIdentifyMergeUnit; template struct VerifyTournamentMerge; -template > +template < + ParallelMergeable I, + class Compare = std::less> class ParallelMerge { public: - typedef std::span> Streams; + using T = typename I::value_type::value_type; private: /** - * Comparator for std::span which defers comparison to the first element of - * the span. + * Comparator for std::span which defers comparison to the first + * element of the span. */ struct span_greater { span_greater(Compare& cmp) : cmp_(cmp) { } - bool operator()(const std::span l, const std::span r) const { + bool operator()( + const std::span l, const std::span r) const { return !(cmp_(l.front(), r.front())); } @@ -295,20 +315,27 @@ class ParallelMerge { * identified by `unit`. */ static Status tournament_merge( - Streams streams, Compare* cmp, const MergeUnit& unit, T* output) { - std::vector> container; + const I& streams, + Compare* cmp, + const MergeUnit& unit, + std::remove_cv_t* output) { + std::vector> container; container.reserve(streams.size()); // NB: we can definitely make a more optimized implementation // which does a bunch of buffering for each battle in the tournament // but this is straightforward - std::priority_queue, std::vector>, span_greater> + std::priority_queue< + std::span, + std::vector>, + span_greater> tournament(span_greater(*cmp), container); for (size_t i = 0; i < streams.size(); i++) { if (unit.starts[i] != unit.ends[i]) { tournament.push( - streams[i].subspan(unit.starts[i], unit.ends[i] - unit.starts[i])); + std::span(streams[i]) + .subspan(unit.starts[i], unit.ends[i] - unit.starts[i])); } } @@ -342,7 +369,7 @@ class ParallelMerge { * `which` is the index of the stream we want to use for the split point. */ static MergeUnit split_point_stream_bounds( - Streams streams, + const I& streams, Compare& cmp, tdb::pmr::memory_resource& memory, uint64_t which, @@ -360,7 +387,7 @@ class ParallelMerge { output.starts[i] = search_bounds.starts[i]; output.ends.push_back(split_point_idx + 1); } else { - std::span substream( + std::span substream( streams[i].begin() + search_bounds.starts[i], streams[i].begin() + search_bounds.ends[i]); @@ -381,7 +408,7 @@ class ParallelMerge { * Holds state for searching for a merge unit of size `target_items`. */ struct SearchMergeBoundary { - Streams streams_; + const I& streams_; Compare& cmp_; tdb::pmr::memory_resource& memory_; uint64_t split_point_stream_; @@ -389,7 +416,7 @@ class ParallelMerge { MergeUnit search_bounds_; SearchMergeBoundary( - Streams streams, + const I& streams, Compare& cmp, tdb::pmr::memory_resource& memory, uint64_t target_items) @@ -488,7 +515,7 @@ class ParallelMerge { * zero for each stream */ static MergeUnit identify_merge_unit( - Streams streams, + const I& streams, Compare* cmp, tdb::pmr::memory_resource& memory, uint64_t target_items) { @@ -521,13 +548,13 @@ class ParallelMerge { */ static Status spawn_next_merge_unit( tiledb::common::ThreadPool* pool, - Streams streams, + const I& streams, Compare* cmp, uint64_t parallel_factor, uint64_t total_items, uint64_t target_unit_size, uint64_t p, - T* output, + std::remove_cv_t* output, ParallelMergeFuture* future) { const uint64_t output_end = std::min(total_items, (p + 1) * target_unit_size); @@ -572,9 +599,9 @@ class ParallelMerge { tiledb::common::ThreadPool& pool, size_t parallel_factor, uint64_t total_items, - Streams streams, + const I& streams, Compare& cmp, - T* output, + std::remove_cv_t* output, ParallelMergeFuture& future) { // NB: round up, if there is a shorter merge unit it will be the last one. const uint64_t target_unit_size = @@ -603,9 +630,9 @@ class ParallelMerge { tiledb::common::ThreadPool& pool, ParallelMergeMemoryResources& memory, const ParallelMergeOptions& options, - Streams streams, + const I& streams, Compare& cmp, - T* output) { + std::remove_cv_t* output) { uint64_t total_items = 0; for (const auto& stream : streams) { total_items += stream.size(); @@ -625,15 +652,15 @@ class ParallelMerge { } }; -template +template tdb::pmr::unique_ptr parallel_merge( tiledb::common::ThreadPool& pool, ParallelMergeMemoryResources& memory, const ParallelMergeOptions& options, - std::span> streams, + const I& streams, Compare& cmp, - T* output) { - return ParallelMerge::start( + std::remove_cv_t* output) { + return ParallelMerge::start( pool, memory, options, streams, cmp, output); } diff --git a/tiledb/common/algorithm/test/unit_parallel_merge.cc b/tiledb/common/algorithm/test/unit_parallel_merge.cc index 8731f4659a8..c402609d08c 100644 --- a/tiledb/common/algorithm/test/unit_parallel_merge.cc +++ b/tiledb/common/algorithm/test/unit_parallel_merge.cc @@ -44,6 +44,19 @@ namespace tiledb::algorithm { template using Streams = std::vector>; +const Streams EXAMPLE_STREAMS = { + {123, 456, 789, 890, 901}, + {135, 357, 579, 791, 913}, + {24, 246, 468, 680, 802}, + {100, 200, 300, 400, 500}}; + +const std::vector> EXAMPLE_SPANS = { + std::span(EXAMPLE_STREAMS[0]), + std::span(EXAMPLE_STREAMS[1]), + std::span(EXAMPLE_STREAMS[2]), + std::span(EXAMPLE_STREAMS[3]), +}; + /** * An instance of an input to the `split_point_stream_bounds` * function. @@ -71,7 +84,7 @@ struct VerifySplitPointStream { } auto cmp = std::less{}; - auto result = ParallelMerge::split_point_stream_bounds( + auto result = ParallelMerge::split_point_stream_bounds( spans, cmp, *memory->get_resource(MemoryType::PARALLEL_MERGE_CONTROL), @@ -109,7 +122,7 @@ struct VerifyIdentifyMergeUnit { *memory_tracker->get_resource(MemoryType::PARALLEL_MERGE_CONTROL); auto cmp = std::less{}; - auto result = ParallelMerge::identify_merge_unit( + auto result = ParallelMerge::identify_merge_unit( spans, &cmp, memory, target_items); RC_ASSERT(target_items == result.num_items()); @@ -166,8 +179,8 @@ struct VerifyTournamentMerge { spans.push_back(std::span(stream)); } - auto result = - ParallelMerge::tournament_merge(spans, &cmp, unit, output_ptr); + auto result = ParallelMerge::tournament_merge( + spans, &cmp, unit, output_ptr); RC_ASSERT(result.ok()); // compare against a naive and slow merge @@ -220,8 +233,8 @@ struct VerifyParallelMerge { ParallelMergeMemoryResources resources(*memory_tracker.get()); ThreadPool pool(pool_concurrency); - auto future = parallel_merge( - pool, resources, options, spans, cmp, &output[0]); + auto future = + parallel_merge(pool, resources, options, spans, cmp, &output[0]); std::optional prev_bound; std::optional bound; @@ -618,23 +631,12 @@ TEST_CASE("parallel merge example", "[algorithm][parallel_merge]") { SECTION("less") { auto cmp = std::less{}; - std::vector> streambufs = { - {123, 456, 789, 890, 901}, - {135, 357, 579, 791, 913}, - {24, 246, 468, 680, 802}, - {100, 200, 300, 400, 500}}; const std::vector expect = {24, 100, 123, 135, 200, 246, 300, 357, 400, 456, 468, 500, 579, 680, 789, 791, 802, 890, 901, 913}; - std::vector> streams = { - std::span(streambufs[0]), - std::span(streambufs[1]), - std::span(streambufs[2]), - std::span(streambufs[3]), - }; - auto future = parallel_merge( - pool, resources, options, streams, cmp, &output[0]); + auto future = parallel_merge( + pool, resources, options, EXAMPLE_SPANS, cmp, &output[0]); future->block(); @@ -645,23 +647,17 @@ TEST_CASE("parallel merge example", "[algorithm][parallel_merge]") { SECTION("greater") { auto cmp = std::greater{}; - std::vector> streambufs = { - {901, 890, 789, 456, 123}, - {913, 791, 579, 357, 135}, - {802, 680, 468, 246, 24}, - {500, 400, 300, 200, 100}}; + auto descending = EXAMPLE_STREAMS; + for (auto& stream : descending) { + std::sort(stream.begin(), stream.end(), std::greater<>()); + } + const std::vector expect = {913, 901, 890, 802, 791, 789, 680, 579, 500, 468, 456, 400, 357, 300, 246, 200, 135, 123, 100, 24}; - std::vector> streams = { - std::span(streambufs[0]), - std::span(streambufs[1]), - std::span(streambufs[2]), - std::span(streambufs[3]), - }; - - auto future = parallel_merge( - pool, resources, options, streams, cmp, &output[0]); + + auto future = + parallel_merge(pool, resources, options, descending, cmp, &output[0]); future->block(); diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index c695e23e381..d30425c11d3 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -90,8 +90,6 @@ struct PreprocessTileMergeFuture { /** merge input, looks unused but must out-live the merge future */ std::vector> fragment_result_tiles_; - std::vector> fragment_result_tile_spans_; - /** comparator, looks unused but must out-live the merge future */ std::shared_ptr cmp_; @@ -106,7 +104,6 @@ struct PreprocessTileMergeFuture { memory_used_ -= sizeof(ResultTileId) * num_tiles; } fragment_result_tiles_.clear(); - fragment_result_tile_spans_.clear(); } public: @@ -569,12 +566,6 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( } /* then do parallel merge */ - auto& fragment_result_tile_spans = future.fragment_result_tile_spans_; - fragment_result_tile_spans.reserve(fragment_result_tiles.size()); - for (auto& f : fragment_result_tiles) { - fragment_result_tile_spans.push_back(std::span(f)); - } - preprocess_tile_order_.num_tiles_ = num_result_tiles; preprocess_tile_order_.tiles_.resize( num_result_tiles, ResultTileId{.fragment_idx_ = 0, .tile_idx_ = 0}); @@ -622,11 +613,11 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( future.cmp_ = std::static_pointer_cast(cmp); } - future.merge_ = algorithm::parallel_merge( + future.merge_ = algorithm::parallel_merge( resources_.compute_tp(), merge_resources, future.merge_options_, - fragment_result_tile_spans, + future.fragment_result_tiles_, *static_cast(future.cmp_.get()), &preprocess_tile_order_.tiles_[0]); }; From 7d857b00a143f6a33b9635052b61f9c09013caa1 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 6 Jan 2025 23:07:45 -0500 Subject: [PATCH 129/228] Add TEST_CASE with identify split point example --- tiledb/common/algorithm/parallel_merge.h | 10 ++- .../algorithm/test/unit_parallel_merge.cc | 77 +++++++++++++++++-- 2 files changed, 79 insertions(+), 8 deletions(-) diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h index 7a4d3c19a51..691c9ca1e88 100644 --- a/tiledb/common/algorithm/parallel_merge.h +++ b/tiledb/common/algorithm/parallel_merge.h @@ -237,6 +237,14 @@ struct MergeUnit { , ends(&resource) { } + MergeUnit( + tdb::pmr::memory_resource& resource, + std::initializer_list starts, + std::initializer_list ends) + : starts(starts, &resource) + , ends(ends, &resource) { + } + /** * @return the number of data items contained inside this merge unit */ @@ -291,7 +299,7 @@ class ParallelMerge { public: using T = typename I::value_type::value_type; - private: + protected: /** * Comparator for std::span which defers comparison to the first * element of the span. diff --git a/tiledb/common/algorithm/test/unit_parallel_merge.cc b/tiledb/common/algorithm/test/unit_parallel_merge.cc index c402609d08c..5230aad0b1d 100644 --- a/tiledb/common/algorithm/test/unit_parallel_merge.cc +++ b/tiledb/common/algorithm/test/unit_parallel_merge.cc @@ -50,13 +50,75 @@ const Streams EXAMPLE_STREAMS = { {24, 246, 468, 680, 802}, {100, 200, 300, 400, 500}}; -const std::vector> EXAMPLE_SPANS = { - std::span(EXAMPLE_STREAMS[0]), - std::span(EXAMPLE_STREAMS[1]), - std::span(EXAMPLE_STREAMS[2]), - std::span(EXAMPLE_STREAMS[3]), +template < + ParallelMergeable I, + class Compare = std::less> +struct ParallelMergePublic : public ParallelMerge { + using ParallelMerge::split_point_stream_bounds; }; +/** + * Illustrates the steps of the split point algorithm + */ +TEST_CASE( + "parallel merge split point stream bounds example", + "[algorithm][parallel_merge]") { + using PM = ParallelMergePublic; + + auto cmp = + std::less{}; + + auto memory_tracker = get_test_memory_tracker(); + auto& resource = + *memory_tracker->get_resource(MemoryType::PARALLEL_MERGE_CONTROL); + + // below illustrates the steps the algorithm takes to identify + // 10 tuples from `EXAMPLE_STREAMS` which comprise a merge unit + + // first step, choose stream 0 as the split point stream, 789 is the split + // point + const MergeUnit search_0(resource, {0, 0, 0, 0}, {5, 5, 5, 5}); + const MergeUnit expect_0(resource, {0, 0, 0, 0}, {3, 3, 4, 5}); + const MergeUnit result_0 = PM::split_point_stream_bounds( + EXAMPLE_STREAMS, cmp, resource, 0, search_0); + REQUIRE(expect_0 == result_0); + + // we found 15 tuples less than 789, discard positions and try again + // using stream 1 midpoint 357 as the split point + const MergeUnit search_1(resource, {0, 0, 0, 0}, {3, 3, 4, 5}); + const MergeUnit expect_1(resource, {0, 0, 0, 0}, {1, 2, 2, 3}); + const MergeUnit result_1 = PM::split_point_stream_bounds( + EXAMPLE_STREAMS, cmp, resource, 1, search_1); + REQUIRE(expect_1 == result_1); + + // we found 8 tuples, add positions to result and then continue + // using stream 2 midpoint 468 as the next split point + const MergeUnit search_2(resource, {1, 2, 2, 3}, {3, 3, 4, 5}); + const MergeUnit expect_2(resource, {1, 2, 2, 3}, {2, 2, 3, 4}); + const MergeUnit result_2 = PM::split_point_stream_bounds( + EXAMPLE_STREAMS, cmp, resource, 2, search_2); + REQUIRE(expect_2 == result_2); + + // that found 3 more tuples which is too many, discard above bounds + // and advance to stream 4 midpoint 400 as split point + const MergeUnit search_3(resource, {1, 2, 2, 3}, {2, 2, 3, 4}); + const MergeUnit expect_3(resource, {1, 2, 2, 3}, {1, 2, 2, 4}); + const MergeUnit result_3 = PM::split_point_stream_bounds( + EXAMPLE_STREAMS, cmp, resource, 3, search_3); + REQUIRE(expect_3 == result_3); + + // that only found itself, add to bounds and then wrap around + // to stream 0 for the next split point 456 + const MergeUnit search_4(resource, {1, 2, 2, 4}, {2, 2, 3, 4}); + const MergeUnit expect_4(resource, {1, 2, 2, 4}, {2, 2, 2, 4}); + const MergeUnit result_4 = PM::split_point_stream_bounds( + EXAMPLE_STREAMS, cmp, resource, 0, search_4); + REQUIRE(expect_4 == result_4); + + // now the algorithm can yield {{0, 0, 0, 0}, {2, 2, 2, 4}} which is exactly + // 10 tuples +} + /** * An instance of an input to the `split_point_stream_bounds` * function. @@ -170,7 +232,8 @@ struct VerifyTournamentMerge { std::vector output(unit.num_items()); - // SAFETY: the merge unit will begin writing at index `unit.output_start()` + // SAFETY: the merge unit will begin writing at index + // `unit.output_start()` T* output_ptr = &output[-unit.output_start()]; std::vector> spans; @@ -636,7 +699,7 @@ TEST_CASE("parallel merge example", "[algorithm][parallel_merge]") { 789, 791, 802, 890, 901, 913}; auto future = parallel_merge( - pool, resources, options, EXAMPLE_SPANS, cmp, &output[0]); + pool, resources, options, EXAMPLE_STREAMS, cmp, &output[0]); future->block(); From 585707d407506153073295170c0c8ef2fa7055e0 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 7 Jan 2025 08:54:54 -0500 Subject: [PATCH 130/228] Next round of msvc,etc compiler errors --- test/src/unit-sparse-global-order-reader.cc | 19 +++++++++++-------- test/support/src/array_templates.h | 3 ++- 2 files changed, 13 insertions(+), 9 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 89fbbc0eceb..ad65bd9b112 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -1418,11 +1418,14 @@ TEST_CASE_METHOD( std::iota( fragment.dim_.begin(), fragment.dim_.end(), - instance.array.dimension_.domain.lower_bound + f); + instance.array.dimension_.domain.lower_bound + static_cast(f)); auto& atts = std::get<0>(fragment.atts_); atts.resize(fragment_size); - std::iota(atts.begin(), atts.end(), fragment_size * num_fragments); + std::iota( + atts.begin(), + atts.end(), + static_cast(fragment_size * num_fragments)); instance.fragments.push_back(fragment); } @@ -2465,7 +2468,7 @@ void CSparseGlobalOrderFx::run(Instance instance) { auto outatts = out.attributes(); std::apply( [&](auto&... field) { - (field.resize(std::max(1UL, expect.size()), 0), ...); + (field.resize(std::max(static_cast(1), expect.size()), 0), ...); }, std::tuple_cat(outdims, outatts)); @@ -2632,13 +2635,13 @@ Gen>> make_subarray_1d( template <> struct Arbitrary { static Gen arbitrary() { - constexpr Datatype DimensionType = Datatype::INT32; - using CoordType = tiledb::type::datatype_traits::value_type; + constexpr Datatype DIMENSION_TYPE = Datatype::INT32; + using CoordType = tiledb::type::datatype_traits::value_type; - auto dimension = gen::arbitrary>(); + auto dimension = gen::arbitrary>(); auto fragments = gen::mapcat( - dimension, [](templates::Dimension dimension) { + dimension, [](templates::Dimension dimension) { auto fragment = rc::make_fragment_1d(dimension.domain); @@ -2654,7 +2657,7 @@ struct Arbitrary { return gen::apply( [](std::tuple< - templates::Dimension, + templates::Dimension, std::vector>, std::vector>> fragments, int num_user_cells) { diff --git a/test/support/src/array_templates.h b/test/support/src/array_templates.h index 91adbc0ef66..8a5a98239d1 100644 --- a/test/support/src/array_templates.h +++ b/test/support/src/array_templates.h @@ -262,7 +262,8 @@ struct query_applicator { uint64_t cell_limit = std::numeric_limits::max()) { std::optional num_cells; auto make_field_size = [&](const std::vector& field) { - const uint64_t field_cells = std::min(cell_limit, field.size()); + const uint64_t field_cells = + std::min(cell_limit, static_cast(field.size())); const uint64_t field_size = field_cells * sizeof(T); if (num_cells.has_value()) { // precondition: each field must have the same number of cells From 3874d70fd08828301898062593de7bf08ae85552 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 7 Jan 2025 09:58:12 -0500 Subject: [PATCH 131/228] Fix MSVC errors --- test/src/unit-sparse-global-order-reader.cc | 6 ++--- test/support/rapidcheck/array_templates.h | 27 +++++++++++---------- 2 files changed, 17 insertions(+), 16 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index ad65bd9b112..4c37403899e 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -1253,7 +1253,7 @@ TEST_CASE_METHOD( auto& f1atts = std::get<0>(fragment1.atts_); f1atts.resize(fragment1.dim_.size()); - std::iota(f1atts.begin(), f1atts.end(), fragment0.dim_.size()); + std::iota(f1atts.begin(), f1atts.end(), int(fragment0.dim_.size())); struct FxRun1D instance; instance.fragments.push_back(fragment0); @@ -1331,7 +1331,7 @@ TEST_CASE_METHOD( auto& f1atts = std::get<0>(fragment1.atts_); f1atts.resize(fragment1.dim_.size()); - std::iota(f1atts.begin(), f1atts.end(), f0atts.size()); + std::iota(f1atts.begin(), f1atts.end(), int(f0atts.size())); struct FxRun1D instance; instance.fragments.push_back(fragment0); @@ -1404,7 +1404,7 @@ TEST_CASE_METHOD( FxRun1D instance; instance.array.capacity_ = num_fragments * 2; - instance.array.dimension_.extent = num_fragments * 2; + instance.array.dimension_.extent = int(num_fragments) * 2; instance.array.allow_dups_ = true; instance.subarray = subarray; diff --git a/test/support/rapidcheck/array_templates.h b/test/support/rapidcheck/array_templates.h index 064e8d29937..524fb7f650d 100644 --- a/test/support/rapidcheck/array_templates.h +++ b/test/support/rapidcheck/array_templates.h @@ -40,11 +40,12 @@ namespace rc { +using namespace tiledb::test; using namespace tiledb::test::templates; template -struct Arbitrary> { - static Gen> arbitrary() { +struct Arbitrary> { + static Gen> arbitrary() { // NB: `gen::inRange` is exclusive at the upper end but tiledb domain is // inclusive. So we have to use `int64_t` to avoid overflow. auto bounds = gen::mapcat(gen::arbitrary(), [](D lb) { @@ -62,7 +63,7 @@ struct Arbitrary> { }); return gen::map(bounds, [](std::pair bounds) { - return Domain(bounds.first, bounds.second); + return templates::Domain(bounds.first, bounds.second); }); } }; @@ -86,7 +87,7 @@ std::optional checked_sub(T a, T b) { } template -Gen make_extent(const Domain& domain) { +Gen make_extent(const templates::Domain& domain) { // upper bound on all possible extents to avoid unreasonably // huge tile sizes static constexpr D extent_limit = static_cast( @@ -118,22 +119,22 @@ Gen make_extent(const Domain& domain) { } template -struct Arbitrary> { - static Gen> arbitrary() { - using CoordType = Dimension::value_type; +struct Arbitrary> { + static Gen> arbitrary() { + using CoordType = templates::Dimension::value_type; auto tup = gen::mapcat( gen::arbitrary>(), [](Domain domain) { return gen::pair(gen::just(domain), make_extent(domain)); }); return gen::map(tup, [](std::pair, CoordType> tup) { - return Dimension{.domain = tup.first, .extent = tup.second}; + return templates::Dimension{.domain = tup.first, .extent = tup.second}; }); } }; template -Gen make_coordinate(const Domain& domain) { +Gen make_coordinate(const templates::Domain& domain) { // `gen::inRange` does an exclusive upper bound, // whereas the domain upper bound is inclusive. // As a result some contortion is required to deal @@ -156,9 +157,9 @@ Gen make_coordinate(const Domain& domain) { } template -Gen> make_range(const Domain& domain) { +Gen> make_range(const templates::Domain& domain) { return gen::apply( - [](D p1, D p2) { return Domain(p1, p2); }, + [](D p1, D p2) { return templates::Domain(p1, p2); }, make_coordinate(domain), make_coordinate(domain)); } @@ -190,7 +191,7 @@ Gen> make_fragment_1d(const Domain& d) { template Gen> make_fragment_2d( - const Domain& d1, const Domain& d2) { + const Domain& d1, const templates::Domain& d2) { auto coord_d1 = make_coordinate(d1); auto coord_d2 = make_coordinate(d2); @@ -219,7 +220,7 @@ Gen> make_fragment_2d( } template <> -void show>(const Domain& domain, std::ostream& os) { +void show>(const templates::Domain& domain, std::ostream& os) { os << "[" << domain.lower_bound << ", " << domain.upper_bound << "]"; } From 50e81c2db29d589596bf9a9873849e22ba722319 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 7 Jan 2025 11:00:53 -0500 Subject: [PATCH 132/228] Non-gcc compiler fixes take 15 --- test/src/unit-sparse-global-order-reader.cc | 2 +- test/support/src/array_templates.h | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 4c37403899e..2acb82c765d 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2468,7 +2468,7 @@ void CSparseGlobalOrderFx::run(Instance instance) { auto outatts = out.attributes(); std::apply( [&](auto&... field) { - (field.resize(std::max(static_cast(1), expect.size()), 0), ...); + (field.resize(std::max(1, expect.size()), 0), ...); }, std::tuple_cat(outdims, outatts)); diff --git a/test/support/src/array_templates.h b/test/support/src/array_templates.h index 8a5a98239d1..0a0663fdd04 100644 --- a/test/support/src/array_templates.h +++ b/test/support/src/array_templates.h @@ -258,7 +258,7 @@ struct query_applicator { * @return a tuple containing the size of each input field */ static auto make_field_sizes( - const std::tuple fields, + const std::tuple&...> fields, uint64_t cell_limit = std::numeric_limits::max()) { std::optional num_cells; auto make_field_size = [&](const std::vector& field) { @@ -288,7 +288,7 @@ struct query_applicator { tiledb_ctx_t* ctx, tiledb_query_t* query, auto& field_sizes, - std::tuple fields, + std::tuple&...> fields, std::function fieldname, uint64_t cell_offset = 0) { auto set_data_buffer = From aec3e0547696cae59f2baccd9e2f0ede6266b021 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 7 Jan 2025 13:54:41 -0500 Subject: [PATCH 133/228] Some sanitization for MSVC --- tiledb/common/algorithm/parallel_merge.h | 3 ++- tiledb/common/algorithm/test/unit_parallel_merge.cc | 5 +++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h index 691c9ca1e88..e9084535e37 100644 --- a/tiledb/common/algorithm/parallel_merge.h +++ b/tiledb/common/algorithm/parallel_merge.h @@ -311,7 +311,8 @@ class ParallelMerge { bool operator()( const std::span l, const std::span r) const { - return !(cmp_(l.front(), r.front())); + // note that this flips the comparison as it is used in a max heap but we want min + return cmp_(r.front(), l.front()); } Compare cmp_; diff --git a/tiledb/common/algorithm/test/unit_parallel_merge.cc b/tiledb/common/algorithm/test/unit_parallel_merge.cc index 5230aad0b1d..3bff3093ae7 100644 --- a/tiledb/common/algorithm/test/unit_parallel_merge.cc +++ b/tiledb/common/algorithm/test/unit_parallel_merge.cc @@ -234,7 +234,8 @@ struct VerifyTournamentMerge { // SAFETY: the merge unit will begin writing at index // `unit.output_start()` - T* output_ptr = &output[-unit.output_start()]; + T* output_buffer = output.data(); + T* output_ptr = output_buffer - unit.output_start(); std::vector> spans; for (size_t s = 0; s < streams.size(); s++) { @@ -297,7 +298,7 @@ struct VerifyParallelMerge { ThreadPool pool(pool_concurrency); auto future = - parallel_merge(pool, resources, options, spans, cmp, &output[0]); + parallel_merge(pool, resources, options, spans, cmp, &output.data()[0]); std::optional prev_bound; std::optional bound; From 84743aca71f09073630a7cebc3acd30a7604f945 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 7 Jan 2025 15:26:09 -0500 Subject: [PATCH 134/228] Cmpable => Comparable --- tiledb/common/algorithm/parallel_merge.h | 3 ++- tiledb/sm/misc/comparators.h | 22 +++++++++++----------- tiledb/sm/misc/type_traits.h | 7 ++++--- tiledb/sm/query/readers/result_coords.h | 2 +- 4 files changed, 18 insertions(+), 16 deletions(-) diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h index e9084535e37..867bc420fc4 100644 --- a/tiledb/common/algorithm/parallel_merge.h +++ b/tiledb/common/algorithm/parallel_merge.h @@ -311,7 +311,8 @@ class ParallelMerge { bool operator()( const std::span l, const std::span r) const { - // note that this flips the comparison as it is used in a max heap but we want min + // note that this flips the comparison as it is used in a max heap but we + // want min return cmp_(r.front(), l.front()); } diff --git a/tiledb/sm/misc/comparators.h b/tiledb/sm/misc/comparators.h index dd793804eeb..37bb260cabe 100644 --- a/tiledb/sm/misc/comparators.h +++ b/tiledb/sm/misc/comparators.h @@ -93,7 +93,7 @@ namespace tiledb::sm { using namespace tiledb::common; namespace cell_compare { -template +template int compare( const Domain& domain, unsigned int d, const RCTypeL& a, const RCTypeR& b) { const auto& dim{*(domain.dimension_ptr(d))}; @@ -117,7 +117,7 @@ class CellCmpBase { , dim_num_(domain.dim_num()) { } - template + template [[nodiscard]] int cell_order_cmp_RC( unsigned int d, const RCTypeL& a, const RCTypeR& b) const { return cell_compare::compare(domain_, d, a, b); @@ -378,7 +378,7 @@ class HilbertCmpRCI : protected CellCmpBase { template struct global_order_compare { - template + template static int compare( const Domain& domain, const GlobalCmpL& a, const GlobalCmpR& b) { const auto num_dims = domain.dim_num(); @@ -427,7 +427,7 @@ class GlobalCellCmpStaticDispatch : public CellCmpBase { CELL_ORDER == Layout::ROW_MAJOR || CELL_ORDER == Layout::COL_MAJOR); } - template + template bool operator()(const GlobalCmpL& a, const GlobalCmpR& b) const { return global_order_compare::compare( domain_, a, b) < 0; @@ -442,7 +442,7 @@ class GlobalCellCmp : public CellCmpBase { , cell_order_(domain.cell_order()) { } - template + template int compare(const GlobalCmpL& a, const GlobalCmpR& b) const { if (tile_order_ == Layout::ROW_MAJOR) { if (cell_order_ == Layout::ROW_MAJOR) { @@ -463,7 +463,7 @@ class GlobalCellCmp : public CellCmpBase { } } - template + template bool operator()(const GlobalCmpL& a, const GlobalCmpR& b) const { return compare(a, b) < 0; } @@ -476,8 +476,8 @@ class GlobalCellCmp : public CellCmpBase { }; template -concept GlobalTileCmpable = - GlobalCellCmpable and requires(const T& a, uint64_t pos) { +concept GlobalTileComparable = + GlobalCellComparable and requires(const T& a, uint64_t pos) { { a.fragment_idx() } -> std::convertible_to; { a.tile_idx() } -> std::convertible_to; { a.tile_->timestamp(pos) } -> std::same_as; @@ -508,13 +508,13 @@ class GlobalCmp : public ResultTileCmpBase { } /** - * Comparison operator for a vector of `GlobalTileCmpable`. + * Comparison operator for a vector of `GlobalTileComparable`. * * @param a The first coordinate. * @param b The second coordinate. * @return `true` if `a` precedes `b` and `false` otherwise. */ - template + template bool operator()(const GlobalCmpL& a, const GlobalCmpR& b) const { const int cellcmp = cellcmp_.compare(a, b); if (cellcmp < 0) { @@ -575,7 +575,7 @@ class GlobalCmpReverse { * @param b The second coordinate. * @return `true` if `a` precedes `b` and `false` otherwise. */ - template + template bool operator()(const GlobalCmpL& a, const GlobalCmpR& b) const { return !cmp_.operator()(a, b); } diff --git a/tiledb/sm/misc/type_traits.h b/tiledb/sm/misc/type_traits.h index 25c746755a9..26867cf47a1 100644 --- a/tiledb/sm/misc/type_traits.h +++ b/tiledb/sm/misc/type_traits.h @@ -45,7 +45,7 @@ namespace tiledb::sm { * (see `tiledb/sm/misc/comparators.h`) */ template -concept CellCmpable = +concept CellComparable = requires(const T& a, const Dimension& dim, unsigned dim_idx) { { a.dimension_datum(dim, dim_idx) } -> std::same_as; }; @@ -55,8 +55,9 @@ concept CellCmpable = * (see `tiledb/sm/misc/comparators.h`) */ template -concept GlobalCellCmpable = - CellCmpable and requires(const T& a, const Dimension& dim, unsigned d) { +concept GlobalCellComparable = + CellComparable and + requires(const T& a, const Dimension& dim, unsigned d) { { a.coord(d) } -> std::convertible_to; }; diff --git a/tiledb/sm/query/readers/result_coords.h b/tiledb/sm/query/readers/result_coords.h index c2f6b527f0e..79eacf6c133 100644 --- a/tiledb/sm/query/readers/result_coords.h +++ b/tiledb/sm/query/readers/result_coords.h @@ -275,7 +275,7 @@ struct GlobalOrderResultCoords * * @return Max slab length that can be merged for this tile. */ - template + template uint64_t max_slab_length( const GlobalOrderLowerBound& next, const CompType& cmp) { uint64_t cell_num = base::tile_->cell_num(); From d823062d90f91cda9fdf6ca20c7fe93fa404b53d Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 7 Jan 2025 15:27:34 -0500 Subject: [PATCH 135/228] '&& requires' instead of 'and requires' --- tiledb/sm/misc/type_traits.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tiledb/sm/misc/type_traits.h b/tiledb/sm/misc/type_traits.h index 26867cf47a1..bccbab90693 100644 --- a/tiledb/sm/misc/type_traits.h +++ b/tiledb/sm/misc/type_traits.h @@ -56,7 +56,7 @@ concept CellComparable = */ template concept GlobalCellComparable = - CellComparable and + CellComparable && requires(const T& a, const Dimension& dim, unsigned d) { { a.coord(d) } -> std::convertible_to; }; From 8ea9d7a61aa26969ab60fcba4e32753fdc415766 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 7 Jan 2025 15:37:55 -0500 Subject: [PATCH 136/228] Improve rapidcheck in cmake --- CMakeLists.txt | 1 + test/CMakeLists.txt | 8 +------- tiledb/common/algorithm/test/CMakeLists.txt | 8 +------- 3 files changed, 3 insertions(+), 14 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 2eb6942eb2a..162c0baaed1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -447,6 +447,7 @@ target_include_directories(local_install INTERFACE ${CMAKE_SOURCE_DIR}) enable_testing() if(TILEDB_TESTS) + find_package(rapidcheck CONFIG REQUIRED) # Add custom Catch2 entry point that suppresses message boxes on debug assertion # failures on Windows CI. find_package(Catch2 REQUIRED) diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 78124b5ec6e..329690f03a2 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -212,12 +212,6 @@ if (NOT MSVC) add_compile_options(-Wno-deprecated-declarations) endif() -find_library( - LIBRAPIDCHECK - NAMES rapidcheck - REQUIRED -) - # unit test executable add_executable( tiledb_unit EXCLUDE_FROM_ALL @@ -241,7 +235,7 @@ target_link_libraries(tiledb_unit Catch2::Catch2 tiledb_test_support_lib configuration_definitions - ${LIBRAPIDCHECK} + rapidcheck ) target_link_libraries(tiledb_unit PRIVATE $) diff --git a/tiledb/common/algorithm/test/CMakeLists.txt b/tiledb/common/algorithm/test/CMakeLists.txt index 2fd63dd3a8d..f200b3c8ad3 100644 --- a/tiledb/common/algorithm/test/CMakeLists.txt +++ b/tiledb/common/algorithm/test/CMakeLists.txt @@ -26,15 +26,9 @@ include(unit_test) -find_library( - LIBRAPIDCHECK - NAMES rapidcheck - REQUIRED -) - commence(unit_test algorithm) this_target_object_libraries(algorithm) this_target_sources(main.cc unit_parallel_merge.cc) this_target_link_libraries(tiledb_test_support_lib) - this_target_link_libraries(${LIBRAPIDCHECK}) + this_target_link_libraries(rapidcheck) conclude(unit_test) From 7e79b1e9e43c92ff2466cb67bd51a2b176c60242 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 7 Jan 2025 20:00:59 -0500 Subject: [PATCH 137/228] Multi-range subarray signal test is more explicit --- test/src/unit-sparse-global-order-reader.cc | 48 +++++++++++++++------ 1 file changed, 34 insertions(+), 14 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 2acb82c765d..2601fbec1b0 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2920,28 +2920,48 @@ TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: multi-range subarray signal", "[sparse-global-order]") { - templates::Fragment1D fragment0; - fragment0.dim_.push_back(1); - std::get<0>(fragment0.atts_).push_back(1); + using Asserter = AsserterCatch; - FxRun1D instance; - instance.fragments.push_back(fragment0); - instance.subarray.push_back({1, 1}); - instance.subarray.push_back({3, 3}); + // Create default array. + reset_config(); + create_default_array_1d(); - // NB: `Rapidcheck` just throws a normal exception, - // we are not actually in a rapidcheck context. - REQUIRE_THROWS(run(instance)); + int coords[5]; + uint64_t coords_size = sizeof(coords); - tiledb_error_t* error = NULL; - auto rc = tiledb_ctx_get_last_error(ctx_, &error); + // Open array + CApiArray array(ctx_, array_name_.c_str(), TILEDB_READ); + + // Create query. + tiledb_query_t* query; + TRY(ctx_, tiledb_query_alloc(ctx_, array, TILEDB_READ, &query)); + TRY(ctx_, tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER)); + TRY(ctx_, + tiledb_query_set_data_buffer(ctx_, query, "d", &coords[0], &coords_size)); + + // Apply subarray + const int lower_1 = 4, upper_1 = 8; + const int lower_2 = 16, upper_2 = 32; + tiledb_subarray_t* sub; + TRY(ctx_, tiledb_subarray_alloc(ctx_, array, &sub)); + TRY(ctx_, + tiledb_subarray_add_range(ctx_, sub, 0, &lower_1, &upper_1, nullptr)); + TRY(ctx_, + tiledb_subarray_add_range(ctx_, sub, 0, &lower_2, &upper_2, nullptr)); + TRY(ctx_, tiledb_query_set_subarray_t(ctx_, query, sub)); + tiledb_subarray_free(&sub); + + auto rc = tiledb_query_submit(ctx_, query); + tiledb_query_free(&query); + REQUIRE(rc == TILEDB_ERR); + + tiledb_error_t* error = nullptr; + rc = tiledb_ctx_get_last_error(ctx_, &error); REQUIRE(rc == TILEDB_OK); - REQUIRE(error != nullptr); const char* msg; rc = tiledb_error_message(error, &msg); REQUIRE(rc == TILEDB_OK); - REQUIRE( std::string(msg).find( "Multi-range reads are not supported on a global order query") != From 80807054305989a749084ad8fb85e11825d07ea9 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 9 Jan 2025 10:45:52 -0500 Subject: [PATCH 138/228] Revert fs order change to vfs_helpers.cc --- test/support/src/vfs_helpers.cc | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/test/support/src/vfs_helpers.cc b/test/support/src/vfs_helpers.cc index 4b447363add..7935f1d4253 100644 --- a/test/support/src/vfs_helpers.cc +++ b/test/support/src/vfs_helpers.cc @@ -66,9 +66,6 @@ std::vector> vfs_test_get_fs_vec() { &supports_gcs, &supports_rest_s3); - // some codes uses fs_vec[0] as the default, default to native filesystem - fs_vec.emplace_back(std::make_unique()); - if (supports_s3) { fs_vec.emplace_back(std::make_unique()); } @@ -94,6 +91,7 @@ std::vector> vfs_test_get_fs_vec() { } } + fs_vec.emplace_back(std::make_unique()); fs_vec.emplace_back(std::make_unique()); return fs_vec; From 9641e3b700316770158a656ccc2adf59624a89b2 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 9 Jan 2025 10:46:08 -0500 Subject: [PATCH 139/228] Print error message if tiledb_object_type fails --- test/src/unit-sparse-global-order-reader.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 2601fbec1b0..a2add624e04 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2309,7 +2309,7 @@ template void CSparseGlobalOrderFx::create_array(const Instance& instance) { tiledb_object_t type; auto rc = tiledb_object_type(ctx_, array_name_.c_str(), &type); - ASSERTER(rc == TILEDB_OK); + ASSERTER("" == error_if_any(rc)); if (type == TILEDB_ARRAY) { rc = tiledb_array_delete(ctx_, array_name_.c_str()); ASSERTER("" == error_if_any(rc)); From 88b11c91bcb2e5f211a4999d6b781d576fd1075b Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 9 Jan 2025 10:48:39 -0500 Subject: [PATCH 140/228] Add docs to tiledb_submit_a_b.cc and make results order configurable --- test/performance/tiledb_submit_a_b.cc | 123 ++++++++++++++++++++++---- 1 file changed, 108 insertions(+), 15 deletions(-) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 342c033751d..5820ac2dc0b 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -1,3 +1,89 @@ +/** + * @file test/performance/tiledb_submit_a_b.cc + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2025 TileDB, 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. + * + * @section DESCRIPTION + * + * This file is an executable whose purpose is to compare the performance + * of a tiledb query running with two different configurations. + * + * Usage: $0 [additional array URIs...] + * + * For each array in the argument list, two queries are created: + * one with configuration "A" and one with configuration "B". + * The `run()` function alternates taking a step (`tiledb_query_submit`) + * with the "A" query and the "B" query, checking that both have the + * same results and recording the time spent calling `tiledb_query_submit`. + * + * After executing upon all of the arrays, the timing information is + * dumped to `/tmp/time_keeper.out`. + * + * The arrays must have the same schema, whose physical type is reflected + * by the `using Fragment = ` declaration in the middle of + * this file. The `using Fragment` declaration sets the types of the buffers + * which are used to read the array. + * + * The nature of the "A" and "B" configurations are specified via the required + * argument `config.json`. The following example illustrates the currently + * supported keys: + * + * ``` + * { + * "a": { + * "config": { + * "sm.query.sparse_global_order.preprocess_tile_merge=0" + * } + * }, + * "b": { + * "config": { + * "sm.query.sparse_global_order.preprocess_tile_merge=128" + * } + * }, + * "query": { + * "layout": "global_order", + * "subarray": [ + * { + * "%": 30 + * } + * ] + * } + * } + * ``` + * + * The paths "a.config" and "b.config" are sets of key-value pairs + * which are used to configure the "A" and "B" queries respectively. + * + * The "query.layout" path is required and sets the results order. + * + * The "query.subarray" path is an optional list of range specifications on + * each dimension. Currently the only supported specification is + * an object with a field "%" which adds a subarray range whose + * bounds cover the specified percent of the non-empty domain + * for that dimension. + */ #include #include #include @@ -60,11 +146,25 @@ struct TimeKeeper { } }; -capi_return_t json2query( +/** + * Constructs the query using the configuration's common "query" options. + */ +capi_return_t construct_query( tiledb_ctx_t* ctx, tiledb_array_t* array, tiledb_query_t* query, const json& jq) { + const auto layout = jq["layout"].get(); + if (layout == "global_order") { + TRY(ctx, tiledb_query_set_layout(ctx, query, TILEDB_GLOBAL_ORDER)); + } else if (layout == "row_major") { + TRY(ctx, tiledb_query_set_layout(ctx, query, TILEDB_ROW_MAJOR)); + } else if (layout == "col_major") { + TRY(ctx, tiledb_query_set_layout(ctx, query, TILEDB_COL_MAJOR)); + } else { + throw std::runtime_error("Invalid 'layout' for query: " + layout); + } + if (jq.find("subarray") != jq.end()) { tiledb_subarray_t* subarray; RETURN_IF_ERR(tiledb_subarray_alloc(ctx, array, &subarray)); @@ -155,16 +255,14 @@ static void run( // Create query which does NOT do merge tiledb_query_t* a_query; TRY(ctx, tiledb_query_alloc(ctx, array, TILEDB_READ, &a_query)); - TRY(ctx, tiledb_query_set_layout(ctx, a_query, TILEDB_GLOBAL_ORDER)); TRY(ctx, tiledb_query_set_config(ctx, a_query, a_config)); - json2query(ctx, array, a_query, query_config); + construct_query(ctx, array, a_query, query_config); // Create query which DOES do merge tiledb_query_t* b_query; TRY(ctx, tiledb_query_alloc(ctx, array, TILEDB_READ, &b_query)); - TRY(ctx, tiledb_query_set_layout(ctx, b_query, TILEDB_GLOBAL_ORDER)); TRY(ctx, tiledb_query_set_config(ctx, b_query, b_config)); - json2query(ctx, array, b_query, query_config); + construct_query(ctx, array, b_query, query_config); // helper to do basic checks on both auto do_submit = [&](auto& key, auto& query, auto& outdata) -> uint64_t { @@ -244,8 +342,13 @@ static void run( } } +// change this to match the schema of the target arrays using Fragment = Fragment2D; +/** + * Reads key-value pairs from a JSON object to construct and return a + * `tiledb_config_t`. + */ capi_return_t json2config(tiledb_config_t** config, const json& j) { tiledb_error_t* error; RETURN_IF_ERR(tiledb_config_alloc(config, &error)); @@ -260,16 +363,6 @@ capi_return_t json2config(tiledb_config_t** config, const json& j) { return TILEDB_OK; } -/** - * Runs sparse global order reader on a 2D array - * with two `int64_t` dimensions and a `float` attribute. - * This schema is common in SOMA, comparing the results - * from "preprocess merge off" and "preprocess merge on". - * - * The time of each `tiledb_query_submit` is recorded - * for both variations, and then dumped to `/tmp/time_keeper.out` - * when the test is completed. - */ int main(int argc, char** argv) { json config; { From 6ceb242c1dc9a1a091ee08918ee81a2d9abff469 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 9 Jan 2025 14:26:42 -0500 Subject: [PATCH 141/228] Fix JSON in example --- test/performance/tiledb_submit_a_b.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 5820ac2dc0b..8018a0d6454 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -54,12 +54,12 @@ * { * "a": { * "config": { - * "sm.query.sparse_global_order.preprocess_tile_merge=0" + * "sm.query.sparse_global_order.preprocess_tile_merge": 0 * } * }, * "b": { * "config": { - * "sm.query.sparse_global_order.preprocess_tile_merge=128" + * "sm.query.sparse_global_order.preprocess_tile_merge": 128 * } * }, * "query": { From 95f455fa13bd0d88b6f4202ea6e64d836a80566f Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 9 Jan 2025 14:27:04 -0500 Subject: [PATCH 142/228] Log exceptions to stderr --- test/performance/tiledb_submit_a_b.cc | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 8018a0d6454..dc46845f7f8 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -97,6 +97,7 @@ #include "external/include/nlohmann/json.hpp" #include +#include #include using namespace tiledb::test; @@ -386,7 +387,12 @@ int main(int argc, char** argv) { static_cast(&argv[2]), argc - 2); for (const auto& array_uri : array_uris) { - run(time_keeper, array_uri, config["query"], a_conf, b_conf); + try { + run(time_keeper, array_uri, config["query"], a_conf, b_conf); + } catch (const std::exception& e) { + std::cerr << "Error on array \"" << array_uri << "\": " << e.what() + << std::endl; + } } tiledb_config_free(&b_conf); From 1a6f45fb10c5f75edc1faa25d0704e85a351153d Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 9 Jan 2025 14:27:28 -0500 Subject: [PATCH 143/228] Return status from do_submit --- test/performance/tiledb_submit_a_b.cc | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index dc46845f7f8..882fbde041a 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -266,7 +266,8 @@ static void run( construct_query(ctx, array, b_query, query_config); // helper to do basic checks on both - auto do_submit = [&](auto& key, auto& query, auto& outdata) -> uint64_t { + auto do_submit = [&](auto& key, auto& query, auto& outdata) + -> std::pair { // make field size locations auto dimension_sizes = [](std::tuple dimensions) { return query_applicator::make_field_sizes(dimensions); @@ -306,26 +307,30 @@ static void run( ASSERTER(dim_num_cells == att_num_cells); if (dim_num_cells < outdata.size()) { + // since the user buffer did not fill up the query must be complete ASSERTER(status == TILEDB_COMPLETED); } - return dim_num_cells; + return std::make_pair(status, dim_num_cells); }; const std::string a_key = std::string(array_uri) + ".a"; const std::string b_key = std::string(array_uri) + ".b"; while (true) { - const uint64_t a_num_cells = do_submit(a_key, a_query, a); - const uint64_t on_num_cells = do_submit(b_key, b_query, b); + tiledb_query_status_t a_status, b_status; + uint64_t a_num_cells, b_num_cells; - ASSERTER(a_num_cells == on_num_cells); + std::tie(a_status, a_num_cells) = do_submit(a_key, a_query, a); + std::tie(b_status, b_num_cells) = do_submit(b_key, b_query, b); + + ASSERTER(a_num_cells == b_num_cells); std::apply( [&](auto&... outfield) { (outfield.resize(a_num_cells), ...); }, std::tuple_cat(a.dimensions(), a.attributes())); std::apply( - [&](auto&... outfield) { (outfield.resize(on_num_cells), ...); }, + [&](auto&... outfield) { (outfield.resize(b_num_cells), ...); }, std::tuple_cat(b.dimensions(), b.attributes())); ASSERTER(a.dimensions() == b.dimensions()); @@ -337,7 +342,8 @@ static void run( reset(a); reset(b); - if (a_num_cells < num_user_cells) { + ASSERTER(a_status == b_status); + if (a_status == TILEDB_COMPLETED) { break; } } From 61dc130ac4845bafb7efa194197d0abed3015137 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Sat, 11 Jan 2025 15:37:07 -0500 Subject: [PATCH 144/228] tiledb_submit_a_b assert that results are in global order --- test/performance/tiledb_submit_a_b.cc | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 882fbde041a..d62e12ad1b4 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -92,6 +92,7 @@ #include "tiledb/sm/array_schema/array_schema.h" #include "tiledb/sm/array_schema/attribute.h" #include "tiledb/sm/array_schema/dimension.h" +#include "tiledb/sm/misc/comparators.h" #include "tiledb/sm/stats/duration_instrument.h" #include "external/include/nlohmann/json.hpp" @@ -317,6 +318,9 @@ static void run( const std::string a_key = std::string(array_uri) + ".a"; const std::string b_key = std::string(array_uri) + ".b"; + tiledb::sm::GlobalCellCmp globalcmp( + array->array()->array_schema_latest().domain()); + while (true) { tiledb_query_status_t a_status, b_status; uint64_t a_num_cells, b_num_cells; @@ -343,6 +347,23 @@ static void run( reset(b); ASSERTER(a_status == b_status); + + // assert that the results arrive in global order + for (size_t i = 1; i < a.size(); i++) { + const auto prevtuple = std::apply( + [&](const std::vector&... dims) { + return global_cell_cmp_std_tuple(std::make_tuple(dims[i - 1]...)); + }, + a.dimensions()); + const auto nexttuple = std::apply( + [&](const std::vector&... dims) { + return global_cell_cmp_std_tuple(std::make_tuple(dims[i]...)); + }, + a.dimensions()); + + ASSERTER(!globalcmp(nexttuple, prevtuple)); + } + if (a_status == TILEDB_COMPLETED) { break; } From 692e517376c38002906348599f53918a696950ab Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 13 Jan 2025 15:12:19 -0500 Subject: [PATCH 145/228] Add 2D out-of-order MBR test --- test/src/unit-sparse-global-order-reader.cc | 186 +++++++++++++++++++- 1 file changed, 179 insertions(+), 7 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index a2add624e04..9c64d14d3e0 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -70,10 +70,18 @@ using tiledb::test::templates::DimensionType; using tiledb::test::templates::FragmentType; using tiledb::test::templates::query_applicator; +template +using Subarray2DType = std::vector>, + std::optional>>>; + namespace rc { Gen>> make_subarray_1d( const templates::Domain& domain); -} + +Gen> make_subarray_2d( + const templates::Domain& d1, const templates::Domain& d2); +} // namespace rc /* ********************************* */ /* STRUCT DEFINITION */ @@ -438,13 +446,18 @@ struct CSparseGlobalOrderFx { template void create_array(const Instance& instance); + template + void run_create(Instance& instance); + template + void run_execute(Instance& instance); + /** * Runs an input against a fresh array. * Inserts fragments one at a time, then reads them back in global order * and checks that what we read out matches what we put in. */ template - void run(Instance instance); + void run(Instance& instance); template std::string error_if_any(CAPIReturn apirc) const; @@ -1452,6 +1465,156 @@ TEST_CASE_METHOD( } } +/** + * Tests that the reader will not yield out of order when + * the tile MBRs in a fragment are not in the global order. + * + * The coordinates in the fragment are in global order, but + * the tile MBRs may not be. This is because the MBR uses + * the minimum coordinate value *in each dimension*, which + * for two dimensions and higher is not always the same as + * the minimum coordinate in the tile. + * + * In this test, we have tile extents of 4 in both dimensions. + * Let's say the attribute value is the index of the cell + * as enumerated in row-major order and we have a densely + * populated array. + * + * c-T1 c-T2 c-T3 + * | | | | + * ---+----+---+---+----+----+---+---+----+----+---+---+----+--- + * | 1 2 3 4 | 5 6 7 8 | 9 10 11 12 | + * r-T1 | 201 202 203 204 | 205 206 207 208 | 209 210 211 212 | ... + * | 401 402 403 404 | 405 406 407 408 | 409 410 411 412 | + * | 601 602 603 604 | 605 606 607 608 | 609 610 611 612 | + * ---+----+---+---+----+----+---+---+----+----+---+---+----+--- + * + * If the capacity is 17, then: + * Data tile 1 holds + * [1, 2, 3, 4, 201, 202, 203, 204, 401, 402, 403, 404, 601, 602, 603, 604, 5]. + * Data tile 2 holds + * [6, 7, 8, 205, 206, 207, 208, 405, 406, 407, 408, 605, 606, 607, 608, 9, 10]. + * + * Data tile 1 has a MBR of [(1, 1), (5, 4)]. + * Data tile 2 has a MBR of [(5, 1), (10, 4)]. + * + * The lower bound of data tile 2's MBR is less than the upper bound + * of data tile 1's MBR. Hence the coordinates of the tiles are in global + * order but the MBRs are not. + * + * In a non-dense setting, this happens if the data tile boundary + * happens in the middle of a space tile which has coordinates on both + * sides, AND the space tile after the boundary contains a coordinate + * which is lesser in the second dimension. + */ +TEST_CASE_METHOD( + CSparseGlobalOrderFx, + "Sparse global order reader: out-of-order MBRs", + "[sparse-global-order][rest]") { + auto doit = [this]( + size_t num_fragments, + size_t fragment_size, + size_t num_user_cells, + size_t tile_capacity, + bool allow_dups, + const Subarray2DType& subarray = {}) { + FxRun2D instance; + instance.num_user_cells = num_user_cells; + instance.capacity = tile_capacity; + instance.allow_dups = allow_dups; + instance.subarray = subarray; + + auto row = [&](size_t f, size_t i) -> int { + return 1 + + static_cast( + ((num_fragments * i) + f) / instance.d1.domain.upper_bound); + }; + auto col = [&](size_t f, size_t i) -> int { + return 1 + + static_cast( + ((num_fragments * i) + f) % instance.d1.domain.upper_bound); + }; + + for (size_t f = 0; f < num_fragments; f++) { + templates::Fragment2D fdata; + fdata.d1_.reserve(fragment_size); + fdata.d2_.reserve(fragment_size); + std::get<0>(fdata.atts_).reserve(fragment_size); + + for (size_t i = 0; i < fragment_size; i++) { + fdata.d1_.push_back(row(f, i)); + fdata.d2_.push_back(col(f, i)); + std::get<0>(fdata.atts_) + .push_back(static_cast(f * fragment_size + i)); + } + + instance.fragments.push_back(fdata); + } + + run_create(instance); + + // validate that we have set up the condition we claim, + // i.e. some fragment has out-of-order MBRs + { + CApiArray array(ctx_, array_name_.c_str(), TILEDB_READ); + + const auto& fragment_metadata = array->array()->fragment_metadata(); + for (const auto& fragment : fragment_metadata) { + const_cast(fragment.get()) + ->loaded_metadata() + ->load_rtree(array->array()->get_encryption_key()); + } + + sm::GlobalCellCmp globalcmp( + array->array()->array_schema_latest().domain()); + + if (std::is_same::value) { + bool any_out_of_order = false; + for (size_t f = 0; !any_out_of_order && f < fragment_metadata.size(); + f++) { + for (size_t t = 1; + !any_out_of_order && t < fragment_metadata[f]->tile_num(); + t++) { + const sm::RangeUpperBound lt = { + .mbr = fragment_metadata[f]->mbr(t - 1)}; + const sm::RangeLowerBound rt = { + .mbr = fragment_metadata[f]->mbr(t)}; + if (globalcmp(rt, lt)) { + any_out_of_order = true; + } + } + } + ASSERTER(any_out_of_order); + } + } + + run_execute(instance); + }; + + SECTION("Example") { + doit.operator()(4, 100, 32, 6, false); + } + + SECTION("Rapidcheck") { + rc::prop("rapidcheck out-of-order MBRs", [doit](bool allow_dups) { + const size_t num_fragments = *rc::gen::inRange(2, 8); + const size_t fragment_size = *rc::gen::inRange(32, 400); + const size_t num_user_cells = *rc::gen::inRange(1, 1024); + const size_t tile_capacity = *rc::gen::inRange(4, 32); + const auto subarray = *rc::make_subarray_2d( + templates::Domain(1, 200), templates::Domain(1, 200)); + + doit.operator()( + num_fragments, + fragment_size, + num_user_cells, + tile_capacity, + allow_dups, + subarray); + }); + } +} + TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: tile offsets budget exceeded", @@ -2377,7 +2540,14 @@ void CSparseGlobalOrderFx::create_array(const Instance& instance) { * expected result order computed from the input data. */ template -void CSparseGlobalOrderFx::run(Instance instance) { +void CSparseGlobalOrderFx::run(Instance& instance) { + reset_config(); + run_create(instance); + run_execute(instance); +} + +template +void CSparseGlobalOrderFx::run_create(Instance& instance) { ASSERTER(instance.num_user_cells > 0); reset_config(); @@ -2393,6 +2563,11 @@ void CSparseGlobalOrderFx::run(Instance instance) { for (auto& fragment : instance.fragments) { write_fragment(fragment); } +} + +template +void CSparseGlobalOrderFx::run_execute(Instance& instance) { + ASSERTER(instance.num_user_cells > 0); std::decay_t expect; for (const auto& fragment : instance.fragments) { @@ -2680,10 +2855,7 @@ struct Arbitrary { /** * @return a generator of valid subarrays within the domains `d1` and `d2` */ -Gen>, - std::optional>>>> -make_subarray_2d( +Gen> make_subarray_2d( const templates::Domain& d1, const templates::Domain& d2) { // NB: multi-range subarray is not supported (yet?) for global order read From 92e70d7aeee9370f146cbabd1b5855eb16b9d5cd Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 13 Jan 2025 15:12:53 -0500 Subject: [PATCH 146/228] UntypedDatumView(std::string_view) --- tiledb/common/types/untyped_datum.h | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tiledb/common/types/untyped_datum.h b/tiledb/common/types/untyped_datum.h index 94e1a684e50..1f61e681ea7 100644 --- a/tiledb/common/types/untyped_datum.h +++ b/tiledb/common/types/untyped_datum.h @@ -45,6 +45,11 @@ class UntypedDatumView { : datum_content_(content) , datum_size_(size) { } + UntypedDatumView(std::string_view ss) + : datum_content_(ss.data()) + , datum_size_(ss.size()) { + } + [[nodiscard]] inline const void* content() const { return datum_content_; } From b67a0a178422b984d1c9363add2be853c78cf798 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 14 Jan 2025 15:17:31 -0500 Subject: [PATCH 147/228] Bury some gory details in array_templates.h --- test/performance/tiledb_submit_a_b.cc | 34 +++----- test/src/unit-sparse-global-order-reader.cc | 97 ++++++++------------- test/support/src/array_templates.h | 49 +++++++++++ 3 files changed, 99 insertions(+), 81 deletions(-) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index d62e12ad1b4..63f2772567f 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -270,22 +270,16 @@ static void run( auto do_submit = [&](auto& key, auto& query, auto& outdata) -> std::pair { // make field size locations - auto dimension_sizes = [](std::tuple dimensions) { - return query_applicator::make_field_sizes(dimensions); - }(outdata.dimensions()); - auto attribute_sizes = [](std::tuple attributes) { - return query_applicator::make_field_sizes(attributes); - }(outdata.attributes()); + auto dimension_sizes = + templates::query::make_field_sizes(outdata.dimensions()); + auto attribute_sizes = + templates::query::make_field_sizes(outdata.attributes()); // add fields to query - [&](std::tuple dims) { - query_applicator::set( - ctx, query, dimension_sizes, dims, dimension_name); - }(outdata.dimensions()); - [&](std::tuple atts) { - query_applicator::set( - ctx, query, attribute_sizes, atts, attribute_name); - }(outdata.attributes()); + templates::query::set_fields( + ctx, query, dimension_sizes, outdata.dimensions(), dimension_name); + templates::query::set_fields( + ctx, query, attribute_sizes, outdata.attributes(), attribute_name); { tiledb::sm::stats::DurationInstrument qtimer = @@ -296,14 +290,10 @@ static void run( tiledb_query_status_t status; TRY(ctx, tiledb_query_get_status(ctx, query, &status)); - const uint64_t dim_num_cells = [&](auto dims) { - return query_applicator::num_cells( - dims, dimension_sizes); - }(outdata.dimensions()); - const uint64_t att_num_cells = [&](auto atts) { - return query_applicator::num_cells( - atts, attribute_sizes); - }(outdata.attributes()); + const uint64_t dim_num_cells = templates::query::num_cells( + outdata.dimensions(), dimension_sizes); + const uint64_t att_num_cells = templates::query::num_cells( + outdata.attributes(), attribute_sizes); ASSERTER(dim_num_cells == att_num_cells); diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 9c64d14d3e0..972f2df1cee 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -68,7 +68,6 @@ using tiledb::sm::Datatype; using tiledb::test::templates::AttributeType; using tiledb::test::templates::DimensionType; using tiledb::test::templates::FragmentType; -using tiledb::test::templates::query_applicator; template using Subarray2DType = std::vector(std::tuple dimensions) { - return query_applicator::make_field_sizes(dimensions); - }(dimensions); - auto attribute_sizes = [](std::tuple attributes) { - return query_applicator::make_field_sizes(attributes); - }(attributes); + auto dimension_sizes = + templates::query::make_field_sizes(dimensions); + auto attribute_sizes = + templates::query::make_field_sizes(attributes); // Create the query. tiledb_query_t* query; @@ -615,20 +612,16 @@ void CSparseGlobalOrderFx::write_fragment(const Fragment& fragment) { ASSERTER(rc == TILEDB_OK); // add dimensions to query - [&](std::tuple dims) { - query_applicator::set( - ctx_, query, dimension_sizes, dims, [](unsigned d) { - return "d" + std::to_string(d + 1); - }); - }(dimensions); + templates::query::set_fields( + ctx_, query, dimension_sizes, dimensions, [](unsigned d) { + return "d" + std::to_string(d + 1); + }); // add attributes to query - [&](std::tuple atts) { - query_applicator::set( - ctx_, query, attribute_sizes, atts, [](unsigned a) { - return "a" + std::to_string(a + 1); - }); - }(attributes); + templates::query::set_fields( + ctx_, query, attribute_sizes, attributes, [](unsigned a) { + return "a" + std::to_string(a + 1); + }); // Submit query. rc = tiledb_query_submit(ctx_, query); @@ -636,12 +629,10 @@ void CSparseGlobalOrderFx::write_fragment(const Fragment& fragment) { // check that sizes match what we expect const uint64_t expect_num_cells = fragment.size(); - const uint64_t dim_num_cells = [&](auto dims) { - return query_applicator::num_cells(dims, dimension_sizes); - }(dimensions); - const uint64_t att_num_cells = [&](auto atts) { - return query_applicator::num_cells(atts, attribute_sizes); - }(attributes); + const uint64_t dim_num_cells = + templates::query::num_cells(dimensions, dimension_sizes); + const uint64_t att_num_cells = + templates::query::num_cells(attributes, attribute_sizes); ASSERTER(dim_num_cells == expect_num_cells); ASSERTER(att_num_cells == expect_num_cells); @@ -2651,34 +2642,26 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { uint64_t outcursor = 0; while (true) { // make field size locations - auto dimension_sizes = [&](std::tuple outdims) { - return query_applicator::make_field_sizes( - outdims, instance.num_user_cells); - }(outdims); - auto attribute_sizes = [&](std::tuple outdims) { - return query_applicator::make_field_sizes( - outdims, instance.num_user_cells); - }(outatts); + auto dimension_sizes = templates::query::make_field_sizes( + outdims, instance.num_user_cells); + auto attribute_sizes = templates::query::make_field_sizes( + outatts, instance.num_user_cells); // add fields to query - [&](std::tuple dims) { - query_applicator::set( - ctx_, - query, - dimension_sizes, - dims, - [](unsigned d) { return "d" + std::to_string(d + 1); }, - outcursor); - }(outdims); - [&](std::tuple atts) { - query_applicator::set( - ctx_, - query, - attribute_sizes, - atts, - [](unsigned a) { return "a" + std::to_string(a + 1); }, - outcursor); - }(outatts); + templates::query::set_fields( + ctx_, + query, + dimension_sizes, + outdims, + [](unsigned d) { return "d" + std::to_string(d + 1); }, + outcursor); + templates::query::set_fields( + ctx_, + query, + attribute_sizes, + outatts, + [](unsigned a) { return "a" + std::to_string(a + 1); }, + outcursor); rc = tiledb_query_submit(ctx_, query); { @@ -2706,14 +2689,10 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { rc = tiledb_query_get_status(ctx_, query, &status); ASSERTER(rc == TILEDB_OK); - const uint64_t dim_num_cells = [&](auto dims) { - return query_applicator::num_cells( - dims, dimension_sizes); - }(outdims); - const uint64_t att_num_cells = [&](auto atts) { - return query_applicator::num_cells( - atts, attribute_sizes); - }(outatts); + const uint64_t dim_num_cells = + templates::query::num_cells(outdims, dimension_sizes); + const uint64_t att_num_cells = + templates::query::num_cells(outatts, attribute_sizes); ASSERTER(dim_num_cells == att_num_cells); diff --git a/test/support/src/array_templates.h b/test/support/src/array_templates.h index 0a0663fdd04..8196390b78a 100644 --- a/test/support/src/array_templates.h +++ b/test/support/src/array_templates.h @@ -343,6 +343,55 @@ struct query_applicator { } }; +/** + * Helper namespace for actually using the `query_applicator`. + * Functions in this namespace help to deduce the template + * instantiation of `query_applicator`. + */ +namespace query { + +/** + * @return a tuple containing the size of each input field + */ +template +auto make_field_sizes( + const auto& fields, + uint64_t cell_limit = std::numeric_limits::max()) { + return [cell_limit](std::tuple fields) { + return query_applicator::make_field_sizes( + fields, cell_limit); + }(fields); +} + +/** + * Set buffers on `query` for the tuple of field columns + */ +template +void set_fields( + tiledb_ctx_t* ctx, + tiledb_query_t* query, + auto& field_sizes, + auto fields, + std::function field_name, + uint64_t cell_offset = 0) { + [&](std::tuple fields) { + query_applicator::set( + ctx, query, field_sizes, fields, field_name, cell_offset); + }(fields); +} + +/** + * @return the number of cells written into `fields` by a read query + */ +template +uint64_t num_cells(const auto& fields, const auto& field_sizes) { + return [&](auto fields) { + return query_applicator::num_cells(fields, field_sizes); + }(fields); +} + +} // namespace query + } // namespace tiledb::test::templates #endif From 2bed9282b6e824de68a274bebd351a6d2df7e3e5 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 15 Jan 2025 16:27:53 -0500 Subject: [PATCH 148/228] tiledb_submit_a_b asserts that produced tuples are in global order --- test/performance/tiledb_submit_a_b.cc | 93 ++++++++++++++++++--------- test/support/src/array_templates.h | 2 +- 2 files changed, 65 insertions(+), 30 deletions(-) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 63f2772567f..22a0f837853 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -89,6 +89,8 @@ #include #include "tiledb/api/c_api/array/array_api_internal.h" +#include "tiledb/api/c_api/context/context_api_internal.h" +#include "tiledb/api/c_api/query/query_api_internal.h" #include "tiledb/sm/array_schema/array_schema.h" #include "tiledb/sm/array_schema/attribute.h" #include "tiledb/sm/array_schema/dimension.h" @@ -207,6 +209,37 @@ capi_return_t construct_query( return TILEDB_OK; } +template +tiledb::common::Status assertGlobalOrder( + tiledb_array_t* array, + const Fragment& data, + size_t num_cells, + size_t start, + size_t end) { + tiledb::sm::GlobalCellCmp globalcmp( + array->array()->array_schema_latest().domain()); + + for (uint64_t i = start + 1; i < end; i++) { + const auto prevtuple = std::apply( + [&](const std::vector&... dims) { + return global_cell_cmp_std_tuple(std::make_tuple(dims[i - 1]...)); + }, + data.dimensions()); + const auto nexttuple = std::apply( + [&](const std::vector&... dims) { + return global_cell_cmp_std_tuple(std::make_tuple(dims[i]...)); + }, + data.dimensions()); + + if (globalcmp(nexttuple, prevtuple)) { + return tiledb::common::Status_Error( + "Out of order: pos=" + std::to_string(i) + + ", num_cells=" + std::to_string(num_cells)); + } + } + return tiledb::common::Status_Ok(); +} + template static void run( TimeKeeper& time_keeper, @@ -220,16 +253,16 @@ static void run( const uint64_t num_user_cells = 1024 * 1024 * 128; - Fragment a; - Fragment b; + Fragment a_data; + Fragment b_data; auto reset = [num_user_cells](Fragment& buf) { std::apply( [&](auto&... outfield) { (outfield.resize(num_user_cells), ...); }, std::tuple_cat(buf.dimensions(), buf.attributes())); }; - reset(a); - reset(b); + reset(a_data); + reset(b_data); tiledb_config_t* config; { @@ -308,50 +341,52 @@ static void run( const std::string a_key = std::string(array_uri) + ".a"; const std::string b_key = std::string(array_uri) + ".b"; - tiledb::sm::GlobalCellCmp globalcmp( - array->array()->array_schema_latest().domain()); - while (true) { tiledb_query_status_t a_status, b_status; uint64_t a_num_cells, b_num_cells; - std::tie(a_status, a_num_cells) = do_submit(a_key, a_query, a); - std::tie(b_status, b_num_cells) = do_submit(b_key, b_query, b); + std::tie(a_status, a_num_cells) = do_submit(a_key, a_query, a_data); + std::tie(b_status, b_num_cells) = do_submit(b_key, b_query, b_data); ASSERTER(a_num_cells == b_num_cells); + ASSERTER(a_num_cells <= num_user_cells); std::apply( [&](auto&... outfield) { (outfield.resize(a_num_cells), ...); }, - std::tuple_cat(a.dimensions(), a.attributes())); + std::tuple_cat(a_data.dimensions(), a_data.attributes())); std::apply( [&](auto&... outfield) { (outfield.resize(b_num_cells), ...); }, - std::tuple_cat(b.dimensions(), b.attributes())); + std::tuple_cat(b_data.dimensions(), b_data.attributes())); - ASSERTER(a.dimensions() == b.dimensions()); + ASSERTER(a_data.dimensions() == b_data.dimensions()); // NB: this is only correct if there are no duplicate coordinates, // in which case we need to adapt what CSparseGlobalOrderFx::run does - ASSERTER(a.attributes() == b.attributes()); + ASSERTER(a_data.attributes() == b_data.attributes()); - reset(a); - reset(b); + reset(a_data); + reset(b_data); ASSERTER(a_status == b_status); - // assert that the results arrive in global order - for (size_t i = 1; i < a.size(); i++) { - const auto prevtuple = std::apply( - [&](const std::vector&... dims) { - return global_cell_cmp_std_tuple(std::make_tuple(dims[i - 1]...)); - }, - a.dimensions()); - const auto nexttuple = std::apply( - [&](const std::vector&... dims) { - return global_cell_cmp_std_tuple(std::make_tuple(dims[i]...)); - }, - a.dimensions()); - - ASSERTER(!globalcmp(nexttuple, prevtuple)); + if (a_query->query_->layout() == tiledb::sm::Layout::GLOBAL_ORDER) { + // assert that the results arrive in global order + // do it in parallel, it is slow + auto* tp = ctx->context().compute_tp(); + const size_t parallel_factor = std::max( + 1, std::min(tp->concurrency_level(), a_num_cells / 1024)); + const size_t items_per = a_num_cells / parallel_factor; + const auto isGlobalOrder = tiledb::sm::parallel_for( + ctx->context().compute_tp(), 0, parallel_factor, [&](uint64_t i) { + const uint64_t mystart = i * items_per; + const uint64_t myend = + std::min((i + 1) * items_per + 1, a_num_cells); + return assertGlobalOrder( + array, a_data, a_num_cells, mystart, myend); + }); + if (!isGlobalOrder.ok()) { + throw std::runtime_error(isGlobalOrder.to_string()); + } } if (a_status == TILEDB_COMPLETED) { diff --git a/test/support/src/array_templates.h b/test/support/src/array_templates.h index 8196390b78a..024cc6176c7 100644 --- a/test/support/src/array_templates.h +++ b/test/support/src/array_templates.h @@ -83,7 +83,7 @@ struct global_cell_cmp_std_tuple { tup_); } - const StdTuple& tup_; + StdTuple tup_; }; /** From 2efe0faad08d866a4e37450c36d4f626ea92c7b8 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 15 Jan 2025 16:46:16 -0500 Subject: [PATCH 149/228] Preprocess merge bound is not the next MBR, fixes performance issue for 2D --- .../readers/sparse_global_order_reader.cc | 238 +++++++++++++++--- .../readers/sparse_global_order_reader.h | 6 +- 2 files changed, 203 insertions(+), 41 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index d30425c11d3..1fd77091425 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -123,6 +123,51 @@ struct PreprocessTileMergeFuture { } }; +/** + * Holds the "merge bound" of the globally ordered stream. + * + * The "merge bound" is the largest known coordinate which + * is guaranteed to appear in the global order prior to + * any of the coordinates in yet-to-be-loaded tiles. + * + * See `preprocess_compute_tile_order`. + * + * The `merge_bound` may be derived from a coordinate + * value in a loaded tile, or from the MBR of a + * yet-to-be-loaded tile. + */ +struct PreprocessTileMergeBound { + PreprocessTileMergeBound(unsigned fragment_idx) + : fragment_idx_(fragment_idx) { + } + + unsigned fragment_idx_; + + std::optional tile_; + std::optional mbr_; + + const void* coord(unsigned d) const { + if (tile_.has_value()) { + return (*tile_)->coord((*tile_)->cell_num() - 1, d); + } else { + return mbr_.value().coord(d); + } + } + + UntypedDatumView dimension_datum(const Dimension& dim, unsigned d) const { + if (tile_.has_value()) { + if (dim.var_size()) { + return UntypedDatumView( + (*tile_)->coord_string((*tile_)->cell_num() - 1, d)); + } else { + return UntypedDatumView{coord(d), dim.coord_size()}; + } + } else { + return mbr_.value().dimension_datum(dim, d); + } + } +}; + /* ****************************** */ /* CONSTRUCTORS */ /* ****************************** */ @@ -463,6 +508,105 @@ bool SparseGlobalOrderReader::add_result_tile( } /** + * Computes the order in which result tiles should be loaded. + * + * The sparse global order reader combines the cells from one or more + * fragments, and returns the combined cells to the user in the + * global order. De-duplication of the coordinates may occur if + * the same coordinates are written to multiple fragments. + * + * Each fragment has a list of tiles. The tiles in these lists are + * arranged in global order. If we have a single fragment, then + * we can just stream the tiles in order from that list to the user. + * + * But we probably have multiple fragments which may or may not overlap + * in any part of the coordinate space. + * + * A naive approach to understanding + * that overlap is load tiles from each fragment and compare the values. + * One problem with this approach is that it requires loading a tile from + * each fragment and keeping those tiles loaded, even if the contents + * of that tile might not appear in the global order for quite a while. + * + * A smarter approach uses the fragment metadata, which we want to load + * anyway, in order to determine the order in which all of the tiles must + * be loaded. This function implements that approach. + * + * The tiles in each fragment are already arranged in the global order, + * so we can combine the fragment tile lists into a single list which + * holds the tiles from all fragments in the order which they must + * be loaded. We will run a "parallel merge" algorithm to do this - + * see `tiledb/common/algorithm/parallel_merge.h`. But what is the + * sort key for the tiles? + * + * The fragment metadata contains the "minimum bounding rectangle" or "MBR" + * of each tile. The MBRs give us a hint for arranging all of the tiles + * in the order in which their contents will fit in the global order. + * + * For one-dimension arrays, this works great. The MBR is equivalent + * to the minimum and maximum of each tile. However... + * + * For two-dimension arrays, the MBR is *not* always the min/max of the tiles. + * It is the min of the coordinates, in each dimension. This means + * that two tiles from the same fragment whose coordinates are in the global + * order might have MBRs which are *not* in the global order. + * + * Example: space tile extent is 3, data tile capacity is 4 + * c-T1 c-T2 + * | | | + * ---+---+---+---+---+---+---+--- + * | a b | f | + * r-T1 | | | + * | c d e | g | + * ---+---+---+---+---+---+---+--- + * + * Data tile 1 holds [a, b, c, d] and data tile 2 holds [e, f, g]. + * + * Data tile 1 has an MBR of [(1, 1), (3, 3)]. + * Data tile 2 has an MBR of [(3, 1), (6, 3)]. + * + * The lower range of data tile 2's MBR is less than the lower range of tile + * 1's. + * + * Does this mean that the MBR is unsuitable as a merge key? + * Surprisingly, the answer is no! We can still use it as a merge key. + * + * If used, then merged tile list would be ordered on MBR, + * but the coordinates within would not necessarily be in global order. + * + * However, the coordinates would still be in global order *for each fragment*. + * The parallel merge algorithm does not re-order the items of its lists. + * + * How do we resolve this? Let's say we have identified a run of N tiles + * which fit in the memory budget, which come from arbitrary fragments, + * and are ordered by their MBR. + * + * Without loading tile N+1, we do not know where the coordinates from + * tiles [1..N] fall in the global order with respect to the coordinates + * from tile N+1. But because the tiles from the same fragment *are* + * ordered, if one of the tiles in [1..N] (say M) is from the same fragment + * as tile N+1, then the max coordinate of tile M can be used as + * a "merge bound", i.e. any coordinates exceeding the bound cannot be + * merged. + * + * (FIXME: this is likely wrong, because there might be tiles from + * another fragment whose lower bound is greater than that of + * tile N+1 but contain coordinates less than the upper bound of M, + * write a test for this) + * + * What if there is no tile in [1..N] from the same fragment as N+1? + * In this case, the MBR of tile N+1 is still a lower bound on what + * the coordinate values from tile N+1 can be, so we can use that + * as the merge bound. + * + * In both cases, if emitting coordinates up to the merge bound does + * not exhaust a tile and free memory, then the query cannot proceed + * and returns an error to the user requesting more memory budget. + * + * And if there is no tile N+1 because there are no more tiles, + * then there is no merge bound and all coordinates can safely + * be emitted! + * * @precondition the `TempReadState` is up to date with which tiles pass the * subarray (e.g. by calling `load_initial_data`) */ @@ -607,6 +751,8 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( const PerFragmentMetadata& fragment_metadata_; }; + ResultTileCmp cmp(array_schema_.domain(), fragment_metadata_); + { std::shared_ptr cmp = tdb::make_shared( "ResultTileCmp", array_schema_.domain(), fragment_metadata_); @@ -1198,7 +1344,8 @@ AddNextCellResult SparseGlobalOrderReader::add_next_cell_to_queue( std::vector& result_tiles_it, const std::vector& result_tiles, TileMinHeap& tile_queue, - std::vector& to_delete) { + std::vector& to_delete, + const std::optional& merge_bound) { auto frag_idx = rc.tile_->frag_idx(); auto dups = array_schema_.allows_dups(); @@ -1259,29 +1406,18 @@ AddNextCellResult SparseGlobalOrderReader::add_next_cell_to_queue( } // If the cell value exceeds the lower bound of the un-populated result - // tiles then it is not correct to emit it; hopefully we cleared out - // a tile somewhere and trying again will make progress - if (preprocess_tile_order_.has_more_tiles()) { - const auto& next_global_order_tile = - preprocess_tile_order_.tiles_[preprocess_tile_order_.cursor_]; - const auto& emit_bound = - fragment_metadata_[next_global_order_tile.fragment_idx_]->mbr( - next_global_order_tile.tile_idx_); - - // Skip comparison if the next one is the same fragment, - // in that case we know the cells are ordered correctly - if (frag_idx != next_global_order_tile.fragment_idx_) { - // FIXME: this can potentially make better slabs if we clamp - // the MBR lower bound using the subarray and/or bitmap - RangeLowerBound target = {.mbr = emit_bound}; - - GlobalCellCmp cmp(array_schema_.domain()); - - if (cmp(target, rc)) { - // more tiles needed, out-of-order tiles is a possibility if we - // continue - return AddNextCellResult::MergeBound; - } + // tiles then it is not correct to emit it; hopefully we clear out + // a tile somewhere and trying again will make progress. + // + // We can skip the comparison if the merge bound fragment is the same + // as the current fragment because that is enough to tell us that + // the coordinates are in order. + if (merge_bound.has_value() && merge_bound->fragment_idx_ != frag_idx) { + GlobalCellCmp cmp(array_schema_.domain()); + if (cmp(*merge_bound, rc)) { + // more tiles needed, out-of-order tiles is a possibility if we + // continue + return AddNextCellResult::MergeBound; } } @@ -1390,11 +1526,31 @@ SparseGlobalOrderReader::merge_result_cell_slabs( TileMinHeap tile_queue(cmp, std::move(container)); // If any fragments needs to load more tiles. - AddNextCellResult add_next_cell_result; + AddNextCellResult add_next_cell_result = AddNextCellResult::FoundCell; // Tile iterators, per fragments. std::vector rt_it(result_tiles.size()); + // For preprocess tile order, compute the merge bound + std::optional merge_bound; + if (preprocess_tile_order_.has_more_tiles()) { + const auto& next_global_order_tile = + preprocess_tile_order_.tiles_[preprocess_tile_order_.cursor_]; + const auto f = next_global_order_tile.fragment_idx_; + + merge_bound.emplace(f); + + if (result_tiles[f].empty()) { + // use the MBR of the next tile + const auto& mbr = + fragment_metadata_[f]->mbr(next_global_order_tile.tile_idx_); + merge_bound->mbr_.emplace(RangeLowerBound{.mbr = mbr}); + } else { + // use the maximum known coordinate of this fragment + merge_bound->tile_.emplace(&result_tiles[f].back()); + } + } + // For all fragments, get the first tile in the sorting queue. std::vector to_delete; throw_if_not_ok(parallel_for( @@ -1410,7 +1566,7 @@ SparseGlobalOrderReader::merge_result_cell_slabs( 0; GlobalOrderResultCoords rc(&*(rt_it[f]), cell_idx); auto res = add_next_cell_to_queue( - rc, rt_it, result_tiles, tile_queue, to_delete); + rc, rt_it, result_tiles, tile_queue, to_delete, merge_bound); { std::unique_lock ul(tile_queue_mutex_); if (res == AddNextCellResult::NeedMoreTiles) { @@ -1489,13 +1645,18 @@ SparseGlobalOrderReader::merge_result_cell_slabs( // Put the next cell from the processed tile in the queue. add_next_cell_result = add_next_cell_to_queue( - to_remove, rt_it, result_tiles, tile_queue, to_delete); + to_remove, rt_it, result_tiles, tile_queue, to_delete, merge_bound); } else { update_frag_idx(tile, to_process.pos_ + 1); // Put the next cell from the processed tile in the queue. add_next_cell_result = add_next_cell_to_queue( - to_process, rt_it, result_tiles, tile_queue, to_delete); + to_process, + rt_it, + result_tiles, + tile_queue, + to_delete, + merge_bound); to_process = tile_queue.top(); tile_queue.pop(); @@ -1525,21 +1686,18 @@ SparseGlobalOrderReader::merge_result_cell_slabs( // Compute the length of the cell slab. uint64_t length = 1; if (to_process.has_next_ || single_cell_only) { - if (preprocess_tile_order_.has_more_tiles()) { + if (merge_bound.has_value()) { // the cell slab may overlap the lower bound of tiles which aren't in - // the queue yet - const auto& next_global_order_tile = - preprocess_tile_order_.tiles_[preprocess_tile_order_.cursor_]; - const auto& emit_bound = - fragment_metadata_[next_global_order_tile.fragment_idx_]->mbr( - next_global_order_tile.tile_idx_); - RangeLowerBound global_order_lower_bound = {.mbr = emit_bound}; + // the queue yet, clamp length using the merge bound (or tile queue) + // FIXME: shouldn't everything in the tile queue already be clamped + // by the merge bound? do we actually need this? stdx::reverse_comparator> cmp( stdx::or_equal(array_schema_.domain())); + if (tile_queue.empty()) { - length = to_process.max_slab_length(global_order_lower_bound, cmp); - } else if (cmp(tile_queue.top(), global_order_lower_bound)) { - length = to_process.max_slab_length(global_order_lower_bound, cmp); + length = to_process.max_slab_length(merge_bound.value(), cmp); + } else if (cmp(tile_queue.top(), merge_bound.value())) { + length = to_process.max_slab_length(merge_bound.value(), cmp); } else { length = to_process.max_slab_length(tile_queue.top(), cmp); } @@ -1601,7 +1759,7 @@ SparseGlobalOrderReader::merge_result_cell_slabs( // Put the next cell in the queue. add_next_cell_result = add_next_cell_to_queue( - to_process, rt_it, result_tiles, tile_queue, to_delete); + to_process, rt_it, result_tiles, tile_queue, to_delete, merge_bound); } user_buffers_full = num_cells == 0; diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index df6cf7ee9fa..5769ec05fa7 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -52,6 +52,7 @@ namespace tiledb::sm { class Array; struct PreprocessTileMergeFuture; +struct PreprocessTileMergeBound; enum class AddNextCellResult { // finished the current tile @@ -373,6 +374,8 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, * @param result_tiles Result tiles per fragment. * @param tile_queue Queue of one result coords, per fragment, sorted. * @param to_delete List of tiles to delete. + * @param merge_bound reference to the bound where results can be correctly + * put in the queue * * @return result of trying to add a cell */ @@ -382,7 +385,8 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, std::vector& result_tiles_it, const std::vector& result_tiles, TileMinHeap& tile_queue, - std::vector& to_delete); + std::vector& to_delete, + const std::optional& merge_bound); /** * Computes a tile's Hilbert values for a tile. From e368b9fb1c124181fc10e9700fe442b2ef32acfb Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 15 Jan 2025 17:00:42 -0500 Subject: [PATCH 150/228] Acknowledge unordered in tiledb_submit_a_b --- test/performance/tiledb_submit_a_b.cc | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 22a0f837853..1c007171ddb 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -165,6 +165,12 @@ capi_return_t construct_query( TRY(ctx, tiledb_query_set_layout(ctx, query, TILEDB_ROW_MAJOR)); } else if (layout == "col_major") { TRY(ctx, tiledb_query_set_layout(ctx, query, TILEDB_COL_MAJOR)); + } else if (layout == "unordered") { + throw std::runtime_error( + "TILEDB_UNORDERED is not implemented; the unstable results order means " + "we cannot compare the coordinates from interleaved submits. This can " + "be implemented by buffering all of the query results and then sorting " + "on the coordinates"); } else { throw std::runtime_error("Invalid 'layout' for query: " + layout); } From b7563513ed9bf9d879f52039d0a407ef64094d6e Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 15 Jan 2025 17:17:27 -0500 Subject: [PATCH 151/228] Review comment docstrings --- tiledb/common/algorithm/test/compile_algorithm_main.cc | 4 ++-- tiledb/common/algorithm/test/main.cc | 2 +- tiledb/common/pmr.h | 1 + tiledb/sm/serialization/tiledb-rest.capnp | 5 +++++ tiledb/type/range/range.h | 2 ++ 5 files changed, 11 insertions(+), 3 deletions(-) diff --git a/tiledb/common/algorithm/test/compile_algorithm_main.cc b/tiledb/common/algorithm/test/compile_algorithm_main.cc index 34970908e08..57aab5bd7a7 100644 --- a/tiledb/common/algorithm/test/compile_algorithm_main.cc +++ b/tiledb/common/algorithm/test/compile_algorithm_main.cc @@ -1,11 +1,11 @@ /** - * @file compile_untyped_datum_main.cc + * @file compile_algorithm_main.cc * * @section LICENSE * * The MIT License * - * @copyright Copyright (c) 2021 TileDB, Inc. + * @copyright Copyright (c) 2025 TileDB, 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 diff --git a/tiledb/common/algorithm/test/main.cc b/tiledb/common/algorithm/test/main.cc index bcfaef59927..f878400f85d 100644 --- a/tiledb/common/algorithm/test/main.cc +++ b/tiledb/common/algorithm/test/main.cc @@ -5,7 +5,7 @@ * * The MIT License * - * @copyright Copyright (c) 2022 TileDB, Inc. + * @copyright Copyright (c) 2025 TileDB, 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 diff --git a/tiledb/common/pmr.h b/tiledb/common/pmr.h index 0eafbab640c..3024ffc9d97 100644 --- a/tiledb/common/pmr.h +++ b/tiledb/common/pmr.h @@ -98,6 +98,7 @@ class unique_ptr_deleter { } memory_resource* resource_; + /** number of members of the array */ size_t nmemb_; size_t alignment_; }; diff --git a/tiledb/sm/serialization/tiledb-rest.capnp b/tiledb/sm/serialization/tiledb-rest.capnp index a0448dd0c62..7625743d405 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp +++ b/tiledb/sm/serialization/tiledb-rest.capnp @@ -708,8 +708,13 @@ struct ReadStateIndex { } struct PreprocessTileOrder { +# State of the sparse global order reader preprocess tile order. + cursor @0 :UInt64; + # Position in the preprocess tile order list. + numTiles @1 :UInt64; + # Number of total tiles in the preprocess tile order list. } struct ReaderIndex { diff --git a/tiledb/type/range/range.h b/tiledb/type/range/range.h index 662a2290286..30d89659d0f 100644 --- a/tiledb/type/range/range.h +++ b/tiledb/type/range/range.h @@ -171,6 +171,8 @@ class Range { set_str_range(s1, s2); } + /** Constructs a range and sets fixed data using values and size of an + * integral type. */ template Range(const T& start, const T& end, const allocator_type& alloc = {}) : Range( From 620c94150bdc38b275e5845c0711a48caa2a86c7 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 15 Jan 2025 17:21:30 -0500 Subject: [PATCH 152/228] auto apirc --- test/support/src/error_helpers.h | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/test/support/src/error_helpers.h b/test/support/src/error_helpers.h index 8b4ec858f67..0fd212a9dca 100644 --- a/test/support/src/error_helpers.h +++ b/test/support/src/error_helpers.h @@ -72,8 +72,7 @@ namespace tiledb::test { * REQUIRE("" == error_if_any(rc)); * ``` */ -template -std::string error_if_any(tiledb_ctx_t* ctx, CAPIReturn apirc) { +std::string error_if_any(tiledb_ctx_t* ctx, auto apirc) { if (apirc == TILEDB_OK) { return ""; } From 91148f79c35b234808028ab107d3184055ee2e09 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 17 Jan 2025 09:36:55 -0500 Subject: [PATCH 153/228] Doc for SparseIndexReaderBase::preprocess_tile_order --- tiledb/sm/query/readers/sparse_index_reader_base.cc | 3 ++- tiledb/sm/query/readers/sparse_index_reader_base.h | 10 ++++++++-- 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_index_reader_base.cc b/tiledb/sm/query/readers/sparse_index_reader_base.cc index 68da67aaf33..ea4c8bab65c 100644 --- a/tiledb/sm/query/readers/sparse_index_reader_base.cc +++ b/tiledb/sm/query/readers/sparse_index_reader_base.cc @@ -137,7 +137,8 @@ void SparseIndexReaderBase::set_read_state(ReadState read_state) { read_state_ = std::move(read_state); } -const PreprocessTileOrder SparseIndexReaderBase::preprocess_tile_order() const { +const PreprocessTileOrder& SparseIndexReaderBase::preprocess_tile_order() + const { return preprocess_tile_order_; } diff --git a/tiledb/sm/query/readers/sparse_index_reader_base.h b/tiledb/sm/query/readers/sparse_index_reader_base.h index 83e49c58d15..003e451039c 100644 --- a/tiledb/sm/query/readers/sparse_index_reader_base.h +++ b/tiledb/sm/query/readers/sparse_index_reader_base.h @@ -621,10 +621,16 @@ class SparseIndexReaderBase : public ReaderBase { */ void set_read_state(ReadState read_state); - const PreprocessTileOrder preprocess_tile_order() const; + /** + * Returns the preprocess tile order state. + * Used to assist the global order reader with deserialization. + * + * @return const reference to the preprocess tile order state + */ + const PreprocessTileOrder& preprocess_tile_order() const; /** - * Sets the preprocess tile order cursor. Used only for deserialization + * Sets the preprocess tile order cursor. Used only for deserialization. * * @param cursor New cursor value. */ From da6a6212b2de6a364a6a08f451f2c16060bfb75d Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 17 Jan 2025 09:37:27 -0500 Subject: [PATCH 154/228] all_fragment_tile_order_ => per_fragment_memory_state_ --- .../query/readers/sparse_global_order_reader.cc | 16 ++++++++-------- .../query/readers/sparse_global_order_reader.h | 6 ++++-- 2 files changed, 12 insertions(+), 10 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 1fd77091425..be829ad7c67 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -201,7 +201,7 @@ SparseGlobalOrderReader::SparseGlobalOrderReader( preprocess_tile_order_.num_tiles_ = 1; // will be adjusted later if needed if (!preprocess_tile_order_.enabled_) { - all_fragment_tile_order_.memory_used_for_coords_.resize( + per_fragment_memory_state_.memory_used_for_coords_.resize( array_->fragment_metadata().size()); } } @@ -481,8 +481,8 @@ bool SparseGlobalOrderReader::add_result_tile( return true; } } else { - if (all_fragment_tile_order_.memory_used_for_coords_[f] + tiles_size > - all_fragment_tile_order_.per_fragment_memory_) { + if (per_fragment_memory_state_.memory_used_for_coords_[f] + tiles_size > + per_fragment_memory_state_.per_fragment_memory_) { return true; } } @@ -492,7 +492,7 @@ bool SparseGlobalOrderReader::add_result_tile( if (!preprocess_tile_order_.enabled_) { // Adjust per fragment memory used. - all_fragment_tile_order_.memory_used_for_coords_[f] += tiles_size; + per_fragment_memory_state_.memory_used_for_coords_[f] += tiles_size; } // Add the tile. @@ -865,7 +865,7 @@ void SparseGlobalOrderReader::create_result_tiles_all_fragments( // Get the number of fragments to process and compute per fragment memory. uint64_t num_fragments_to_process = tmp_read_state_.num_fragments_to_process(); - all_fragment_tile_order_.per_fragment_memory_ = + per_fragment_memory_state_.per_fragment_memory_ = memory_budget_.total_budget() * memory_budget_.ratio_coords() / num_fragments_to_process; @@ -903,7 +903,7 @@ void SparseGlobalOrderReader::create_result_tiles_all_fragments( "budget, tile size : " + std::to_string(tiles_size) + ", per fragment memory " + std::to_string( - all_fragment_tile_order_.per_fragment_memory_) + + per_fragment_memory_state_.per_fragment_memory_) + ", total budget " + std::to_string(memory_budget_.total_budget()) + ", num fragments to process " + @@ -953,7 +953,7 @@ void SparseGlobalOrderReader::create_result_tiles_all_fragments( "budget, tile size : " + std::to_string(tiles_size) + ", per fragment memory " + std::to_string( - all_fragment_tile_order_.per_fragment_memory_) + + per_fragment_memory_state_.per_fragment_memory_) + ", total budget " + std::to_string(memory_budget_.total_budget()) + ", num fragments to process " + @@ -2835,7 +2835,7 @@ void SparseGlobalOrderReader::remove_result_tile( get_coord_tiles_size(array_schema_.dim_num(), frag_idx, tile_idx); if (!preprocess_tile_order_.enabled_) { - all_fragment_tile_order_.memory_used_for_coords_[frag_idx] -= tiles_size; + per_fragment_memory_state_.memory_used_for_coords_[frag_idx] -= tiles_size; } // Adjust total memory usage. diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index 5769ec05fa7..77e2a949eb7 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -155,17 +155,19 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, std::vector result_tiles_leftover_; /** - * State for the default mode to evenly distribute memory + * State for the mode to evenly distribute memory * budget amongst the fragments and create a result * tile per fragment regardless of how their tiles * fit in the unified global order. + * + * Used only when preprocess tile order is not enabled. */ struct { /** Memory used for coordinates tiles per fragment */ std::vector memory_used_for_coords_; /** Memory budget per fragment */ double per_fragment_memory_; - } all_fragment_tile_order_; + } per_fragment_memory_state_; /** Enables consolidation with timestamps or not. */ bool consolidation_with_timestamps_; From 049520658f2e862f697b7523b6c7c418445537da Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 17 Jan 2025 09:37:44 -0500 Subject: [PATCH 155/228] Doc comment for preprocess_compute_result_tile_order --- .../readers/sparse_global_order_reader.h | 22 ++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index 77e2a949eb7..17b4eef3483 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -248,12 +248,28 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, std::vector& result_tiles); /** - * Computes the single list of tiles across all fragments + * Kicks off computation of the single list of tiles across all fragments * arranged in the order they must be processed for this query. * See `preprocess_tile_order_`. * - * @param [out] merge_future where to put input for the merge and the merge - * future + * The `merge_future` in-out parameter provides memory locations for + * the parallel merge algorithm inputs - this includes the global order + * comparator as well as the fragment `ResultTileId` lists. This method sets + * the parallel merge algorithm future on `merge_future` as its postcondition. + * + * The merge output is written to `this->preprocess_tile_order_.tiles_` + * and the `merge_future` can be used to poll the state of this asynchronous + * operation. + * + * @param [in-out] merge_future where to put data for the merge and the merge + * + * @precondition `merge_future` is freshly constructed. + * @postcondition `merge_future.fragment_result_tiles_` is initialized with + * the lists of tiles from each fragment which qualify for the subarray. + * @postcondition `merge_future.cmp_` holds the memory for the comparator used + * in the asynchronous parallel merge. + * @postcondition `merge_future.merge_` is initialized and can be used to poll + * the results of the asynchronous parallel merge. */ void preprocess_compute_result_tile_order( PreprocessTileMergeFuture& merge_future); From f2ad89b666feb45b18ffee818ebec69449a5142b Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 17 Jan 2025 09:40:08 -0500 Subject: [PATCH 156/228] Remove maybe_ from name --- tiledb/sm/query/readers/sparse_global_order_reader.cc | 4 ++-- tiledb/sm/query/readers/sparse_global_order_reader.h | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index be829ad7c67..1b461dbd79f 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -811,7 +811,7 @@ template std::vector SparseGlobalOrderReader::create_result_tiles( std::vector& result_tiles, - std::optional& maybe_preprocess_future) { + std::optional& preprocess_future) { auto timer_se = stats_->start_timer("create_result_tiles"); // Distinguish between leftover result tiles from the previous `submit` @@ -822,7 +822,7 @@ SparseGlobalOrderReader::create_result_tiles( } if (preprocess_tile_order_.enabled_) { - create_result_tiles_using_preprocess(result_tiles, maybe_preprocess_future); + create_result_tiles_using_preprocess(result_tiles, preprocess_future); } else { create_result_tiles_all_fragments(result_tiles); } diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index 17b4eef3483..4daa5e7b64c 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -278,14 +278,14 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, * Create the result tiles. * * @param result_tiles Result tiles per fragment. - * @param maybe_preprocess_future future for polling the global order tile + * @param preprocess_future future for polling the global order tile * stream, if running in preprocess mode * * @return Newly created tiles. */ std::vector create_result_tiles( std::vector& result_tiles, - std::optional& maybe_preprocess_future); + std::optional& preprocess_future); /** * Create the result tiles naively, without coordinating From 05c1e630e80036be1fe2b76c475ed76921346bea Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 17 Jan 2025 09:42:45 -0500 Subject: [PATCH 157/228] PreprocessTileMergeFuture::await checks merge_ first --- tiledb/sm/query/readers/sparse_global_order_reader.cc | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 1b461dbd79f..dd82f29b0c7 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -108,6 +108,9 @@ struct PreprocessTileMergeFuture { public: std::optional await() { + if (!merge_.has_value()) { + return std::nullopt; + } auto ret = merge_.value()->await(); if (merge_.value()->finished()) { free_input(); From dc784da20c65d7022efa147e2bcff9da5a79c83b Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 17 Jan 2025 10:17:06 -0500 Subject: [PATCH 158/228] DeleteArrayGuard, use instead of manual delete in create_array --- test/src/unit-sparse-global-order-reader.cc | 27 +++++--------- test/support/src/array_helpers.h | 40 +++++++++++++++++++++ 2 files changed, 48 insertions(+), 19 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 972f2df1cee..d6bb7174f5c 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -446,7 +446,7 @@ struct CSparseGlobalOrderFx { void create_array(const Instance& instance); template - void run_create(Instance& instance); + DeleteArrayGuard run_create(Instance& instance); template void run_execute(Instance& instance); @@ -515,14 +515,6 @@ void CSparseGlobalOrderFx::update_config() { template void CSparseGlobalOrderFx::create_default_array_1d( const DefaultArray1DConfig& config) { - tiledb_object_t type; - auto rc = tiledb_object_type(ctx_, array_name_.c_str(), &type); - ASSERTER(rc == TILEDB_OK); - if (type == TILEDB_ARRAY) { - rc = tiledb_array_delete(ctx_, array_name_.c_str()); - ASSERTER("" == error_if_any(rc)); - } - tiledb::test::create_array( ctx_, array_name_, @@ -2461,14 +2453,6 @@ TEST_CASE_METHOD( */ template void CSparseGlobalOrderFx::create_array(const Instance& instance) { - tiledb_object_t type; - auto rc = tiledb_object_type(ctx_, array_name_.c_str(), &type); - ASSERTER("" == error_if_any(rc)); - if (type == TILEDB_ARRAY) { - rc = tiledb_array_delete(ctx_, array_name_.c_str()); - ASSERTER("" == error_if_any(rc)); - } - const auto dimensions = instance.dimensions(); const auto attributes = instance.attributes(); @@ -2533,12 +2517,13 @@ void CSparseGlobalOrderFx::create_array(const Instance& instance) { template void CSparseGlobalOrderFx::run(Instance& instance) { reset_config(); - run_create(instance); + + auto tmparray = run_create(instance); run_execute(instance); } template -void CSparseGlobalOrderFx::run_create(Instance& instance) { +DeleteArrayGuard CSparseGlobalOrderFx::run_create(Instance& instance) { ASSERTER(instance.num_user_cells > 0); reset_config(); @@ -2550,10 +2535,14 @@ void CSparseGlobalOrderFx::run_create(Instance& instance) { // create_default_array_1d(instance.array); create_array(instance); + DeleteArrayGuard arrayguard(ctx_, array_name_.c_str()); + // write all fragments for (auto& fragment : instance.fragments) { write_fragment(fragment); } + + return arrayguard; } template diff --git a/test/support/src/array_helpers.h b/test/support/src/array_helpers.h index c7e01dff37b..7d5e221018e 100644 --- a/test/support/src/array_helpers.h +++ b/test/support/src/array_helpers.h @@ -40,6 +40,46 @@ namespace tiledb::test { +/** + * RAII to make sure an array is deleted before exiting a scope. + * + * This is useful within rapidcheck properties which may + * want to use the same temp directory and array name + * for each instance of a test. + */ +struct DeleteArrayGuard { + DeleteArrayGuard(tiledb_ctx_t* ctx, const char* array_uri) + : ctx_(ctx) + , array_uri_(array_uri) { + } + + DeleteArrayGuard(DeleteArrayGuard&& movefrom) + : ctx_(movefrom.ctx_) + , array_uri_(movefrom.array_uri_) { + movefrom.release(); + } + + ~DeleteArrayGuard() { + del(); + } + + capi_return_t del() { + if (ctx_ && array_uri_) { + return tiledb_array_delete(ctx_, array_uri_); + } else { + return TILEDB_OK; + } + } + + void release() { + ctx_ = nullptr; + array_uri_ = nullptr; + } + + tiledb_ctx_t* ctx_; + const char* array_uri_; +}; + /** * RAII to make sure we close our arrays so that keeping the same array URI * open from one test to the next doesn't muck things up From 3ad84ce37729e7a35ca1816199fd5eff965b8ff9 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 17 Jan 2025 10:54:43 -0500 Subject: [PATCH 159/228] Fix 2d rapidcheck test --- test/src/unit-sparse-global-order-reader.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index d6bb7174f5c..4dc33318543 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -1534,7 +1534,7 @@ TEST_CASE_METHOD( instance.fragments.push_back(fdata); } - run_create(instance); + auto guard = run_create(instance); // validate that we have set up the condition we claim, // i.e. some fragment has out-of-order MBRs From 75ef9df905d5adfb7baf039ea44f5d2fae3f9272 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 17 Jan 2025 10:55:12 -0500 Subject: [PATCH 160/228] Enable col major tile/cell orders for 2d tests --- test/src/unit-sparse-global-order-reader.cc | 57 ++++++++++++++++++--- 1 file changed, 49 insertions(+), 8 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 4dc33318543..077988e08d9 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -134,6 +134,16 @@ struct FxRun1D { return array.allow_dups_; } + tiledb_layout_t tile_order() const { + // for 1D it is the same + return TILEDB_ROW_MAJOR; + } + + tiledb_layout_t cell_order() const { + // for 1D it is the same + return TILEDB_ROW_MAJOR; + } + /** * Add `subarray` to a read query */ @@ -221,15 +231,18 @@ struct FxRun2D { uint64_t capacity; bool allow_dups; + tiledb_layout_t tile_order_; + tiledb_layout_t cell_order_; templates::Dimension d1; templates::Dimension d2; SparseGlobalOrderReaderMemoryBudget memory; FxRun2D() - : num_user_cells(8) - , capacity(64) - , allow_dups(true) { + : capacity(64) + , allow_dups(true) + , tile_order_(TILEDB_ROW_MAJOR) + , cell_order_(TILEDB_COL_MAJOR) { d1.domain = templates::Domain(1, 200); d1.extent = 8; d2.domain = templates::Domain(1, 200); @@ -244,6 +257,14 @@ struct FxRun2D { return allow_dups; } + tiledb_layout_t tile_order() const { + return tile_order_; + } + + tiledb_layout_t cell_order() const { + return cell_order_; + } + /** * Add `subarray` to a read query */ @@ -1495,6 +1516,8 @@ TEST_CASE_METHOD( "Sparse global order reader: out-of-order MBRs", "[sparse-global-order][rest]") { auto doit = [this]( + tiledb_layout_t tile_order, + tiledb_layout_t cell_order, size_t num_fragments, size_t fragment_size, size_t num_user_cells, @@ -1505,6 +1528,8 @@ TEST_CASE_METHOD( instance.num_user_cells = num_user_cells; instance.capacity = tile_capacity; instance.allow_dups = allow_dups; + instance.tile_order_ = tile_order; + instance.cell_order_ = cell_order; instance.subarray = subarray; auto row = [&](size_t f, size_t i) -> int { @@ -1575,11 +1600,16 @@ TEST_CASE_METHOD( }; SECTION("Example") { - doit.operator()(4, 100, 32, 6, false); + doit.operator()( + TILEDB_ROW_MAJOR, TILEDB_ROW_MAJOR, 4, 100, 32, 6, false); } SECTION("Rapidcheck") { rc::prop("rapidcheck out-of-order MBRs", [doit](bool allow_dups) { + const auto tile_order = + *rc::gen::element(TILEDB_ROW_MAJOR, TILEDB_COL_MAJOR); + const auto cell_order = + *rc::gen::element(TILEDB_ROW_MAJOR, TILEDB_COL_MAJOR); const size_t num_fragments = *rc::gen::inRange(2, 8); const size_t fragment_size = *rc::gen::inRange(32, 400); const size_t num_user_cells = *rc::gen::inRange(1, 1024); @@ -1588,6 +1618,8 @@ TEST_CASE_METHOD( templates::Domain(1, 200), templates::Domain(1, 200)); doit.operator()( + tile_order, + cell_order, num_fragments, fragment_size, num_user_cells, @@ -2501,8 +2533,8 @@ void CSparseGlobalOrderFx::create_array(const Instance& instance) { attribute_types, attribute_cell_val_nums, attribute_compressors, - TILEDB_ROW_MAJOR, - TILEDB_ROW_MAJOR, + instance.tile_order(), + instance.cell_order(), instance.tile_capacity(), instance.allow_duplicates()); } @@ -2874,9 +2906,14 @@ struct Arbitrary { }); auto num_user_cells = gen::inRange(1, 8 * 1024 * 1024); + auto tile_order = gen::element(TILEDB_ROW_MAJOR, TILEDB_COL_MAJOR); + auto cell_order = gen::element(TILEDB_ROW_MAJOR, TILEDB_COL_MAJOR); return gen::apply( - [](auto fragments, int num_user_cells) { + [](auto fragments, + int num_user_cells, + tiledb_layout_t tile_order, + tiledb_layout_t cell_order) { FxRun2D instance; std::tie( instance.d1, instance.d2, instance.subarray, instance.fragments) = @@ -2885,11 +2922,15 @@ struct Arbitrary { // TODO: capacity, subarray instance.num_user_cells = num_user_cells; instance.allow_dups = true; + instance.tile_order_ = tile_order; + instance.cell_order_ = cell_order; return instance; }, fragments, - num_user_cells); + num_user_cells, + tile_order, + cell_order); } }; From 9ea370e78b1ae4b50e87ed420528d9f97a78c689 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 17 Jan 2025 11:08:38 -0500 Subject: [PATCH 161/228] CSparseGlobalOrderFx uses vfs_test_setup_ context --- test/src/unit-sparse-global-order-reader.cc | 239 ++++++++++---------- 1 file changed, 122 insertions(+), 117 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 077988e08d9..94ff94c7ead 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -411,13 +411,16 @@ concept InstanceType = requires(const T& instance) { struct CSparseGlobalOrderFx { VFSTestSetup vfs_test_setup_; - tiledb_ctx_t* ctx_ = nullptr; std::string array_name_; const char* ARRAY_NAME = "test_sparse_global_order"; tiledb_array_t* array_ = nullptr; SparseGlobalOrderReaderMemoryBudget memory_; + tiledb_ctx_t* context() const { + return vfs_test_setup_.ctx_c; + } + template void create_default_array_1d( const DefaultArray1DConfig& config = DefaultArray1DConfig()); @@ -488,7 +491,7 @@ struct CSparseGlobalOrderFx { template std::string CSparseGlobalOrderFx::error_if_any(CAPIReturn apirc) const { - return tiledb::test::error_if_any(ctx_, apirc); + return tiledb::test::error_if_any(context(), apirc); } CSparseGlobalOrderFx::CSparseGlobalOrderFx() { @@ -501,7 +504,6 @@ CSparseGlobalOrderFx::~CSparseGlobalOrderFx() { if (array_) { tiledb_array_free(&array_); } - tiledb_ctx_free(&ctx_); } void CSparseGlobalOrderFx::reset_config() { @@ -510,9 +512,6 @@ void CSparseGlobalOrderFx::reset_config() { } void CSparseGlobalOrderFx::update_config() { - if (ctx_ != nullptr) - tiledb_ctx_free(&ctx_); - tiledb_config_t* config; tiledb_error_t* error = nullptr; REQUIRE(tiledb_config_alloc(&config, &error) == TILEDB_OK); @@ -528,16 +527,14 @@ void CSparseGlobalOrderFx::update_config() { REQUIRE(memory_.apply(config) == nullptr); - REQUIRE(tiledb_ctx_alloc(config, &ctx_) == TILEDB_OK); - REQUIRE(error == nullptr); - tiledb_config_free(&config); + vfs_test_setup_.update_config(config); } template void CSparseGlobalOrderFx::create_default_array_1d( const DefaultArray1DConfig& config) { tiledb::test::create_array( - ctx_, + context(), array_name_, TILEDB_SPARSE, {"d"}, @@ -558,7 +555,7 @@ void CSparseGlobalOrderFx::create_default_array_1d_strings(bool allow_dups) { int domain[] = {1, 200}; int tile_extent = 2; tiledb::test::create_array( - ctx_, + context(), array_name_, TILEDB_SPARSE, {"d"}, @@ -579,21 +576,21 @@ template void CSparseGlobalOrderFx::write_1d_fragment( int* coords, uint64_t* coords_size, int* data, uint64_t* data_size) { // Open array for writing. - CApiArray array(ctx_, array_name_.c_str(), TILEDB_WRITE); + CApiArray array(context(), array_name_.c_str(), TILEDB_WRITE); // Create the query. tiledb_query_t* query; - auto rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); + auto rc = tiledb_query_alloc(context(), array, TILEDB_WRITE, &query); ASSERTER(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); + rc = tiledb_query_set_layout(context(), query, TILEDB_UNORDERED); ASSERTER(rc == TILEDB_OK); - rc = tiledb_query_set_data_buffer(ctx_, query, "a", data, data_size); + rc = tiledb_query_set_data_buffer(context(), query, "a", data, data_size); ASSERTER(rc == TILEDB_OK); - rc = tiledb_query_set_data_buffer(ctx_, query, "d", coords, coords_size); + rc = tiledb_query_set_data_buffer(context(), query, "d", coords, coords_size); ASSERTER(rc == TILEDB_OK); // Submit query. - rc = tiledb_query_submit(ctx_, query); + rc = tiledb_query_submit(context(), query); ASSERTER("" == error_if_any(rc)); // Clean up. @@ -606,7 +603,7 @@ void CSparseGlobalOrderFx::write_1d_fragment( template void CSparseGlobalOrderFx::write_fragment(const Fragment& fragment) { // Open array for writing. - CApiArray array(ctx_, array_name_.c_str(), TILEDB_WRITE); + CApiArray array(context(), array_name_.c_str(), TILEDB_WRITE); const auto dimensions = fragment.dimensions(); const auto attributes = fragment.attributes(); @@ -619,25 +616,25 @@ void CSparseGlobalOrderFx::write_fragment(const Fragment& fragment) { // Create the query. tiledb_query_t* query; - auto rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); + auto rc = tiledb_query_alloc(context(), array, TILEDB_WRITE, &query); ASSERTER(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); + rc = tiledb_query_set_layout(context(), query, TILEDB_UNORDERED); ASSERTER(rc == TILEDB_OK); // add dimensions to query templates::query::set_fields( - ctx_, query, dimension_sizes, dimensions, [](unsigned d) { + context(), query, dimension_sizes, dimensions, [](unsigned d) { return "d" + std::to_string(d + 1); }); // add attributes to query templates::query::set_fields( - ctx_, query, attribute_sizes, attributes, [](unsigned a) { + context(), query, attribute_sizes, attributes, [](unsigned a) { return "a" + std::to_string(a + 1); }); // Submit query. - rc = tiledb_query_submit(ctx_, query); + rc = tiledb_query_submit(context(), query); ASSERTER("" == error_if_any(rc)); // check that sizes match what we expect @@ -663,30 +660,31 @@ void CSparseGlobalOrderFx::write_1d_fragment_strings( uint64_t* offsets_size) { // Open array for writing. tiledb_array_t* array; - auto rc = tiledb_array_alloc(ctx_, array_name_.c_str(), &array); + auto rc = tiledb_array_alloc(context(), array_name_.c_str(), &array); REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); + rc = tiledb_array_open(context(), array, TILEDB_WRITE); REQUIRE(rc == TILEDB_OK); // Create the query. tiledb_query_t* query; - rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); + rc = tiledb_query_alloc(context(), array, TILEDB_WRITE, &query); REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); + rc = tiledb_query_set_layout(context(), query, TILEDB_UNORDERED); REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_set_data_buffer(ctx_, query, "a", data, data_size); + rc = tiledb_query_set_data_buffer(context(), query, "a", data, data_size); REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_set_offsets_buffer(ctx_, query, "a", offsets, offsets_size); + rc = tiledb_query_set_offsets_buffer( + context(), query, "a", offsets, offsets_size); REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_set_data_buffer(ctx_, query, "d", coords, coords_size); + rc = tiledb_query_set_data_buffer(context(), query, "d", coords, coords_size); REQUIRE(rc == TILEDB_OK); // Submit query. - rc = tiledb_query_submit(ctx_, query); + rc = tiledb_query_submit(context(), query); REQUIRE(rc == TILEDB_OK); // Close array. - rc = tiledb_array_close(ctx_, array); + rc = tiledb_array_close(context(), array); REQUIRE(rc == TILEDB_OK); // Clean up. @@ -698,32 +696,32 @@ void CSparseGlobalOrderFx::write_delete_condition( char* value_to_delete, uint64_t value_size) { // Open array for delete. tiledb_array_t* array; - auto rc = tiledb_array_alloc(ctx_, array_name_.c_str(), &array); + auto rc = tiledb_array_alloc(context(), array_name_.c_str(), &array); REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_open(ctx_, array, TILEDB_DELETE); + rc = tiledb_array_open(context(), array, TILEDB_DELETE); REQUIRE(rc == TILEDB_OK); // Create the query. tiledb_query_t* query; - rc = tiledb_query_alloc(ctx_, array, TILEDB_DELETE, &query); + rc = tiledb_query_alloc(context(), array, TILEDB_DELETE, &query); REQUIRE(rc == TILEDB_OK); // Add condition. tiledb_query_condition_t* qc; - rc = tiledb_query_condition_alloc(ctx_, &qc); + rc = tiledb_query_condition_alloc(context(), &qc); CHECK(rc == TILEDB_OK); rc = tiledb_query_condition_init( - ctx_, qc, "a", value_to_delete, value_size, TILEDB_EQ); + context(), qc, "a", value_to_delete, value_size, TILEDB_EQ); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_condition(ctx_, query, qc); + rc = tiledb_query_set_condition(context(), query, qc); CHECK(rc == TILEDB_OK); // Submit query. - rc = tiledb_query_submit(ctx_, query); + rc = tiledb_query_submit(context(), query); REQUIRE(rc == TILEDB_OK); // Close array. - rc = tiledb_array_close(ctx_, array); + rc = tiledb_array_close(context(), array); REQUIRE(rc == TILEDB_OK); // Clean up. @@ -743,65 +741,65 @@ int32_t CSparseGlobalOrderFx::read( CApiArray* array_ret, std::vector subarray) { // Open array for reading. - CApiArray array(ctx_, array_name_.c_str(), TILEDB_READ); + CApiArray array(context(), array_name_.c_str(), TILEDB_READ); // Create query. tiledb_query_t* query; - auto rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); + auto rc = tiledb_query_alloc(context(), array, TILEDB_READ, &query); CHECK(rc == TILEDB_OK); if (set_subarray) { // Set subarray. tiledb_subarray_t* sub; - rc = tiledb_subarray_alloc(ctx_, array, &sub); + rc = tiledb_subarray_alloc(context(), array, &sub); CHECK(rc == TILEDB_OK); - rc = tiledb_subarray_set_subarray(ctx_, sub, subarray.data()); + rc = tiledb_subarray_set_subarray(context(), sub, subarray.data()); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_subarray_t(ctx_, query, sub); + rc = tiledb_query_set_subarray_t(context(), query, sub); CHECK(rc == TILEDB_OK); tiledb_subarray_free(&sub); } if (qc_idx != 0) { tiledb_query_condition_t* query_condition = nullptr; - rc = tiledb_query_condition_alloc(ctx_, &query_condition); + rc = tiledb_query_condition_alloc(context(), &query_condition); CHECK(rc == TILEDB_OK); if (qc_idx == 1) { int32_t val = 11; rc = tiledb_query_condition_init( - ctx_, query_condition, "a", &val, sizeof(int32_t), TILEDB_LT); + context(), query_condition, "a", &val, sizeof(int32_t), TILEDB_LT); CHECK(rc == TILEDB_OK); } else if (qc_idx == 2) { // Negated query condition should produce the same results. int32_t val = 11; tiledb_query_condition_t* qc; - rc = tiledb_query_condition_alloc(ctx_, &qc); + rc = tiledb_query_condition_alloc(context(), &qc); CHECK(rc == TILEDB_OK); rc = tiledb_query_condition_init( - ctx_, qc, "a", &val, sizeof(int32_t), TILEDB_GE); + context(), qc, "a", &val, sizeof(int32_t), TILEDB_GE); CHECK(rc == TILEDB_OK); - rc = tiledb_query_condition_negate(ctx_, qc, &query_condition); + rc = tiledb_query_condition_negate(context(), qc, &query_condition); CHECK(rc == TILEDB_OK); tiledb_query_condition_free(&qc); } - rc = tiledb_query_set_condition(ctx_, query, query_condition); + rc = tiledb_query_set_condition(context(), query, query_condition); CHECK(rc == TILEDB_OK); tiledb_query_condition_free(&query_condition); } - rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); + rc = tiledb_query_set_layout(context(), query, TILEDB_GLOBAL_ORDER); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_data_buffer(ctx_, query, "a", data, data_size); + rc = tiledb_query_set_data_buffer(context(), query, "a", data, data_size); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_data_buffer(ctx_, query, "d", coords, coords_size); + rc = tiledb_query_set_data_buffer(context(), query, "d", coords, coords_size); CHECK(rc == TILEDB_OK); // Submit query. - auto ret = tiledb_query_submit(ctx_, query); + auto ret = tiledb_query_submit(context(), query); if (query_ret == nullptr || array_ret == nullptr) { // Clean up (RAII will do it for the array) tiledb_query_free(&query); @@ -826,42 +824,43 @@ int32_t CSparseGlobalOrderFx::read_strings( std::vector subarray) { // Open array for reading. tiledb_array_t* array; - auto rc = tiledb_array_alloc(ctx_, array_name_.c_str(), &array); + auto rc = tiledb_array_alloc(context(), array_name_.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx_, array, TILEDB_READ); + rc = tiledb_array_open(context(), array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Create query. tiledb_query_t* query; - rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); + rc = tiledb_query_alloc(context(), array, TILEDB_READ, &query); CHECK(rc == TILEDB_OK); if (set_subarray) { // Set subarray. tiledb_subarray_t* sub; - rc = tiledb_subarray_alloc(ctx_, array, &sub); + rc = tiledb_subarray_alloc(context(), array, &sub); CHECK(rc == TILEDB_OK); - rc = tiledb_subarray_set_subarray(ctx_, sub, subarray.data()); + rc = tiledb_subarray_set_subarray(context(), sub, subarray.data()); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_subarray_t(ctx_, query, sub); + rc = tiledb_query_set_subarray_t(context(), query, sub); CHECK(rc == TILEDB_OK); tiledb_subarray_free(&sub); } - rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); + rc = tiledb_query_set_layout(context(), query, TILEDB_GLOBAL_ORDER); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_data_buffer(ctx_, query, "a", data, data_size); + rc = tiledb_query_set_data_buffer(context(), query, "a", data, data_size); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_offsets_buffer(ctx_, query, "a", offsets, offsets_size); + rc = tiledb_query_set_offsets_buffer( + context(), query, "a", offsets, offsets_size); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_data_buffer(ctx_, query, "d", coords, coords_size); + rc = tiledb_query_set_data_buffer(context(), query, "d", coords, coords_size); CHECK(rc == TILEDB_OK); // Submit query. - auto ret = tiledb_query_submit(ctx_, query); + auto ret = tiledb_query_submit(context(), query); if (query_ret == nullptr || array_ret == nullptr) { // Clean up. - rc = tiledb_array_close(ctx_, array); + rc = tiledb_array_close(context(), array); CHECK(rc == TILEDB_OK); tiledb_array_free(&array); tiledb_query_free(&query); @@ -1046,7 +1045,7 @@ TEST_CASE_METHOD( // Check we hit the correct error. tiledb_error_t* error = NULL; - rc = tiledb_ctx_get_last_error(ctx_, &error); + rc = tiledb_ctx_get_last_error(context(), &error); CHECK(rc == TILEDB_OK); const char* msg; @@ -1122,9 +1121,9 @@ TEST_CASE_METHOD( } // Check incomplete query status. - tiledb_query_get_status(ctx_, query, &status); + tiledb_query_get_status(context(), query, &status); if (status == TILEDB_INCOMPLETE) { - rc = tiledb_query_submit(ctx_, query); + rc = tiledb_query_submit(context(), query); CHECK(rc == TILEDB_OK); } } while (status == TILEDB_INCOMPLETE); @@ -1211,9 +1210,9 @@ TEST_CASE_METHOD( } // Check incomplete query status. - tiledb_query_get_status(ctx_, query, &status); + tiledb_query_get_status(context(), query, &status); if (status == TILEDB_INCOMPLETE) { - rc = tiledb_query_submit(ctx_, query); + rc = tiledb_query_submit(context(), query); CHECK(rc == TILEDB_OK); } } while (status == TILEDB_INCOMPLETE); @@ -1564,7 +1563,7 @@ TEST_CASE_METHOD( // validate that we have set up the condition we claim, // i.e. some fragment has out-of-order MBRs { - CApiArray array(ctx_, array_name_.c_str(), TILEDB_READ); + CApiArray array(context(), array_name_.c_str(), TILEDB_READ); const auto& fragment_metadata = array->array()->fragment_metadata(); for (const auto& fragment : fragment_metadata) { @@ -1665,7 +1664,7 @@ TEST_CASE_METHOD( // Check we hit the correct error. tiledb_error_t* error = NULL; - rc = tiledb_ctx_get_last_error(ctx_, &error); + rc = tiledb_ctx_get_last_error(context(), &error); CHECK(rc == TILEDB_OK); const char* msg; @@ -1754,7 +1753,7 @@ TEST_CASE_METHOD( // Check incomplete query status. tiledb_query_status_t status; - tiledb_query_get_status(ctx_, query, &status); + tiledb_query_get_status(context(), query, &status); CHECK(status == TILEDB_COMPLETED); CHECK(40 == data_r_size); @@ -1766,7 +1765,7 @@ TEST_CASE_METHOD( CHECK(!std::memcmp(data_c, data_r, data_r_size)); // Clean up. - rc = tiledb_array_close(ctx_, array); + rc = tiledb_array_close(context(), array); CHECK(rc == TILEDB_OK); tiledb_query_free(&query); } @@ -1810,7 +1809,7 @@ TEST_CASE_METHOD( // Check we hit the correct error. tiledb_error_t* error = NULL; - rc = tiledb_ctx_get_last_error(ctx_, &error); + rc = tiledb_ctx_get_last_error(context(), &error); CHECK(rc == TILEDB_OK); const char* msg; @@ -2265,7 +2264,7 @@ TEST_CASE_METHOD( &query, &array); CHECK(rc == TILEDB_OK); - tiledb_query_get_status(ctx_, query, &status); + tiledb_query_get_status(context(), query, &status); CHECK(status == TILEDB_INCOMPLETE); uint64_t loop_idx = 1; @@ -2276,9 +2275,9 @@ TEST_CASE_METHOD( loop_idx++; while (status == TILEDB_INCOMPLETE) { - rc = tiledb_query_submit(ctx_, query); + rc = tiledb_query_submit(context(), query); CHECK("" == error_if_any(rc)); - tiledb_query_get_status(ctx_, query, &status); + tiledb_query_get_status(context(), query, &status); CHECK(4 == data_r_size); CHECK(4 == coords_r_size); CHECK(!std::memcmp(&loop_idx, coords_r, coords_r_size)); @@ -2334,10 +2333,10 @@ TEST_CASE_METHOD( for (int i = 3; i <= 21; i++) { // Check incomplete query status. - tiledb_query_get_status(ctx_, query, &status); + tiledb_query_get_status(context(), query, &status); CHECK(status == TILEDB_INCOMPLETE); - rc = tiledb_query_submit(ctx_, query); + rc = tiledb_query_submit(context(), query); CHECK(rc == TILEDB_OK); CHECK(coords_r[0] == i / 2); @@ -2348,10 +2347,10 @@ TEST_CASE_METHOD( for (int i = 2; i <= 10; i++) { // Check incomplete query status. - tiledb_query_get_status(ctx_, query, &status); + tiledb_query_get_status(context(), query, &status); CHECK(status == TILEDB_INCOMPLETE); - rc = tiledb_query_submit(ctx_, query); + rc = tiledb_query_submit(context(), query); CHECK(rc == TILEDB_OK); CHECK(coords_r[0] == i); @@ -2360,7 +2359,7 @@ TEST_CASE_METHOD( } // Check completed query status. - tiledb_query_get_status(ctx_, query, &status); + tiledb_query_get_status(context(), query, &status); CHECK(status == TILEDB_COMPLETED); // Clean up. @@ -2445,7 +2444,7 @@ TEST_CASE_METHOD( CHECK(!std::memcmp(offsets_c, offsets_r, offsets_r_size)); // Check completed query status. - tiledb_query_get_status(ctx_, query, &status); + tiledb_query_get_status(context(), query, &status); CHECK(status == TILEDB_INCOMPLETE); // Reset buffer sizes. @@ -2454,7 +2453,7 @@ TEST_CASE_METHOD( offsets_r_size = sizeof(offsets_r); // Submit query. - rc = tiledb_query_submit(ctx_, query); + rc = tiledb_query_submit(context(), query); REQUIRE(rc == TILEDB_OK); // Validate the second read. @@ -2469,11 +2468,11 @@ TEST_CASE_METHOD( CHECK(!std::memcmp(offsets_c2, offsets_r, offsets_r_size)); // Check completed query status. - tiledb_query_get_status(ctx_, query, &status); + tiledb_query_get_status(context(), query, &status); CHECK(status == TILEDB_COMPLETED); // Clean up. - rc = tiledb_array_close(ctx_, array); + rc = tiledb_array_close(context(), array); CHECK(rc == TILEDB_OK); tiledb_array_free(&array); tiledb_query_free(&query); @@ -2522,7 +2521,7 @@ void CSparseGlobalOrderFx::create_array(const Instance& instance) { attributes); tiledb::test::create_array( - ctx_, + context(), array_name_, TILEDB_SPARSE, dimension_names, @@ -2567,7 +2566,7 @@ DeleteArrayGuard CSparseGlobalOrderFx::run_create(Instance& instance) { // create_default_array_1d(instance.array); create_array(instance); - DeleteArrayGuard arrayguard(ctx_, array_name_.c_str()); + DeleteArrayGuard arrayguard(context(), array_name_.c_str()); // write all fragments for (auto& fragment : instance.fragments) { @@ -2606,7 +2605,7 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { } // Open array for reading. - CApiArray array(ctx_, array_name_.c_str(), TILEDB_READ); + CApiArray array(context(), array_name_.c_str(), TILEDB_READ); // sort for naive comparison { @@ -2635,16 +2634,17 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { // Create query tiledb_query_t* query; - auto rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); + auto rc = tiledb_query_alloc(context(), array, TILEDB_READ, &query); ASSERTER(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); + rc = tiledb_query_set_layout(context(), query, TILEDB_GLOBAL_ORDER); ASSERTER(rc == TILEDB_OK); if (!instance.subarray.empty()) { tiledb_subarray_t* subarray; - TRY(ctx_, tiledb_subarray_alloc(ctx_, array, &subarray)); - TRY(ctx_, instance.template apply_subarray(ctx_, subarray)); - TRY(ctx_, tiledb_query_set_subarray_t(ctx_, query, subarray)); + TRY(context(), tiledb_subarray_alloc(context(), array, &subarray)); + TRY(context(), + instance.template apply_subarray(context(), subarray)); + TRY(context(), tiledb_query_set_subarray_t(context(), query, subarray)); tiledb_subarray_free(&subarray); } @@ -2670,21 +2670,21 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { // add fields to query templates::query::set_fields( - ctx_, + context(), query, dimension_sizes, outdims, [](unsigned d) { return "d" + std::to_string(d + 1); }, outcursor); templates::query::set_fields( - ctx_, + context(), query, attribute_sizes, outatts, [](unsigned a) { return "a" + std::to_string(a + 1); }, outcursor); - rc = tiledb_query_submit(ctx_, query); + rc = tiledb_query_submit(context(), query); { const auto err = error_if_any(rc); if (err.find("Cannot load enough tiles to emit results from all " @@ -2692,7 +2692,7 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { if (!vfs_test_setup_.is_rest()) { // skip for REST since we will not have access to tile sizes ASSERTER(!can_complete_in_memory_budget( - ctx_, array_name_.c_str(), instance)); + context(), array_name_.c_str(), instance)); } tiledb_query_free(&query); return; @@ -2707,7 +2707,7 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { } tiledb_query_status_t status; - rc = tiledb_query_get_status(ctx_, query, &status); + rc = tiledb_query_get_status(context(), query, &status); ASSERTER(rc == TILEDB_OK); const uint64_t dim_num_cells = @@ -2777,8 +2777,8 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { // lastly, check the correctness of our memory budgeting function // (skip for REST since we will not have access to tile sizes) if (!vfs_test_setup_.is_rest()) { - ASSERTER( - can_complete_in_memory_budget(ctx_, array_name_.c_str(), instance)); + ASSERTER(can_complete_in_memory_budget( + context(), array_name_.c_str(), instance)); } } @@ -3111,33 +3111,37 @@ TEST_CASE_METHOD( uint64_t coords_size = sizeof(coords); // Open array - CApiArray array(ctx_, array_name_.c_str(), TILEDB_READ); + CApiArray array(context(), array_name_.c_str(), TILEDB_READ); // Create query. tiledb_query_t* query; - TRY(ctx_, tiledb_query_alloc(ctx_, array, TILEDB_READ, &query)); - TRY(ctx_, tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER)); - TRY(ctx_, - tiledb_query_set_data_buffer(ctx_, query, "d", &coords[0], &coords_size)); + TRY(context(), tiledb_query_alloc(context(), array, TILEDB_READ, &query)); + TRY(context(), + tiledb_query_set_layout(context(), query, TILEDB_GLOBAL_ORDER)); + TRY(context(), + tiledb_query_set_data_buffer( + context(), query, "d", &coords[0], &coords_size)); // Apply subarray const int lower_1 = 4, upper_1 = 8; const int lower_2 = 16, upper_2 = 32; tiledb_subarray_t* sub; - TRY(ctx_, tiledb_subarray_alloc(ctx_, array, &sub)); - TRY(ctx_, - tiledb_subarray_add_range(ctx_, sub, 0, &lower_1, &upper_1, nullptr)); - TRY(ctx_, - tiledb_subarray_add_range(ctx_, sub, 0, &lower_2, &upper_2, nullptr)); - TRY(ctx_, tiledb_query_set_subarray_t(ctx_, query, sub)); + TRY(context(), tiledb_subarray_alloc(context(), array, &sub)); + TRY(context(), + tiledb_subarray_add_range( + context(), sub, 0, &lower_1, &upper_1, nullptr)); + TRY(context(), + tiledb_subarray_add_range( + context(), sub, 0, &lower_2, &upper_2, nullptr)); + TRY(context(), tiledb_query_set_subarray_t(context(), query, sub)); tiledb_subarray_free(&sub); - auto rc = tiledb_query_submit(ctx_, query); + auto rc = tiledb_query_submit(context(), query); tiledb_query_free(&query); REQUIRE(rc == TILEDB_ERR); tiledb_error_t* error = nullptr; - rc = tiledb_ctx_get_last_error(ctx_, &error); + rc = tiledb_ctx_get_last_error(context(), &error); REQUIRE(rc == TILEDB_OK); const char* msg; @@ -3148,3 +3152,4 @@ TEST_CASE_METHOD( "Multi-range reads are not supported on a global order query") != std::string::npos); } + From 6f271d776bcf6756f3e1ce46dc265120ba083606 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 17 Jan 2025 11:10:00 -0500 Subject: [PATCH 162/228] Format oops --- test/src/unit-sparse-global-order-reader.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 94ff94c7ead..b9bb4f001f7 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -3152,4 +3152,3 @@ TEST_CASE_METHOD( "Multi-range reads are not supported on a global order query") != std::string::npos); } - From b756484a2f84e4752b00b46ab14b0f41603faf5f Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 17 Jan 2025 22:29:23 -0500 Subject: [PATCH 163/228] Test fragment skew 2d merge bound --- test/src/unit-sparse-global-order-reader.cc | 180 ++++++++++++++++++-- 1 file changed, 169 insertions(+), 11 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index b9bb4f001f7..7cf0c829df4 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -242,7 +242,7 @@ struct FxRun2D { : capacity(64) , allow_dups(true) , tile_order_(TILEDB_ROW_MAJOR) - , cell_order_(TILEDB_COL_MAJOR) { + , cell_order_(TILEDB_ROW_MAJOR) { d1.domain = templates::Domain(1, 200); d1.extent = 8; d2.domain = templates::Domain(1, 200); @@ -396,6 +396,7 @@ template concept InstanceType = requires(const T& instance) { { instance.tile_capacity() } -> std::convertible_to; { instance.allow_duplicates() } -> std::same_as; + { instance.tile_order() } -> std::same_as; { instance.num_user_cells } -> std::convertible_to; @@ -873,16 +874,26 @@ int32_t CSparseGlobalOrderFx::read_strings( } /** - * @return true if the array fragments are "too wide" to merge with the given - * memory budget. "too wide" means that there are overlapping tiles from + * Determines whether the array fragments are "too wide" to merge with the given + * memory budget. "Too wide" means that there are overlapping tiles from * different fragments to fit in memory, so the merge cannot progress without * producing out-of-order data*. * * *there are ways to get around this but they are not implemented. + * + * An answer cannot be determined if the tile MBR lower bounds within a fragment + * are not in order. This is common for 2+ dimensions, so this won't even try. + * + * @return std::nullopt if an answer cannot be determined, true/false if it can */ -template -static bool can_complete_in_memory_budget( +template +static std::optional can_complete_in_memory_budget( tiledb_ctx_t* ctx, const char* array_uri, const Instance& instance) { + if (std::tuple_size_v > 1) { + // don't even bother + return std::nullopt; + } + CApiArray array(ctx, array_uri, TILEDB_READ); const auto& fragment_metadata = array->array()->fragment_metadata(); @@ -912,7 +923,8 @@ static bool can_complete_in_memory_budget( return data_size + rt_size + subarray_size; }; - sm::GlobalCellCmp globalcmp(array->array()->array_schema_latest().domain()); + const auto& domain = array->array()->array_schema_latest().domain(); + sm::GlobalCellCmp globalcmp(domain); stdx::reverse_comparator reverseglobalcmp(globalcmp); using RT = sm::ResultTileId; @@ -1483,7 +1495,7 @@ TEST_CASE_METHOD( * as enumerated in row-major order and we have a densely * populated array. * - * c-T1 c-T2 c-T3 + * c-T1 c-T2 c-T3 * | | | | * ---+----+---+---+----+----+---+---+----+----+---+---+----+--- * | 1 2 3 4 | 5 6 7 8 | 9 10 11 12 | @@ -1629,6 +1641,145 @@ TEST_CASE_METHOD( } } +/** + * Similar to the "fragment skew" test, but in two dimensions. + * In 2+ dimensions the lower bounds of the tile MBRs are not + * necessarily in order for each fragment. + * + * This test verifies the need to set the merge bound to + * the MBR lower bound of fragments which haven't had any tiles loaded. + * + * Let's use an example with dimension extents and tile capacities of 4. + * + * c-T1 c-T2 c-T3 + * | | | | + * ---+----+---+---+----+----+---+---+----+----+---+---+----+--- + * | 1 1 1 1 | 1 | 1 | + * r-T1 | 1 1 1 1 | | | + * | 1 1 1 1 | | | + * | 1 1 | 2 1 1 | | + * ---+----+---+---+----+----+---+---+----+----+---+---+----+--- + * + * Fragment 1 MBR lower bounds: [(1, 1), (2, 1), (3, 1), (1, 5), (1, 7)] + * Fragment 2 MBR lower bounds: [(4, 6)] + * + * What if the memory budget here permits loading just four tiles? + * + * The un-loaded tiles have bounds (1, 7) and (4, 6), but the + * coordinate from (4, 6) has a lesser value. The merge bound + * is necessary to ensure we don't emit out-of-order coordinates. + */ +TEST_CASE_METHOD( + CSparseGlobalOrderFx, + "Sparse global order reader: fragment skew 2d merge bound", + "[sparse-global-order]") { + auto doit = [this]( + tiledb_layout_t tile_order, + tiledb_layout_t cell_order, + size_t approximate_memory_tiles, + size_t num_user_cells, + size_t num_fragments, + size_t tile_capacity, + bool allow_dups, + const Subarray2DType& subarray = {}) { + FxRun2D instance; + instance.tile_order_ = tile_order; + instance.cell_order_ = cell_order; + instance.d1.extent = 4; + instance.d2.extent = 4; + instance.capacity = tile_capacity; + instance.allow_dups = allow_dups; + instance.num_user_cells = num_user_cells; + instance.subarray = subarray; + + const size_t tile_size_estimate = (1600 + instance.capacity * sizeof(int)); + const double coords_ratio = + (1.02 / (std::stold(instance.memory.total_budget_) / + tile_size_estimate / approximate_memory_tiles)); + instance.memory.ratio_coords_ = std::to_string(coords_ratio); + + int att = 0; + + // for each fragment, make one fragment which is just a point + // so that its MBR is equal to its coordinate (and thus more likely + // to be out of order with respect to the MBRs of tiles from other + // fragments) + for (size_t f = 0; f < num_fragments; f++) { + FxRun2D::FragmentType fdata; + // make one mostly dense space tile + const int trow = instance.d1.domain.lower_bound + + static_cast(f * instance.d1.extent); + const int tcol = instance.d2.domain.lower_bound + + static_cast(f * instance.d2.extent); + for (int i = 0; i < instance.d1.extent * instance.d2.extent - 2; i++) { + fdata.d1_.push_back(trow + i / instance.d1.extent); + fdata.d2_.push_back(tcol + i % instance.d1.extent); + std::get<0>(fdata.atts_).push_back(att++); + } + + // then some sparse coords in the next space tile, + // fill the data tile (if the capacity is 4), we'll call it T + fdata.d1_.push_back(trow); + fdata.d2_.push_back(tcol + instance.d2.extent); + std::get<0>(fdata.atts_).push_back(att++); + fdata.d1_.push_back(trow + instance.d1.extent - 1); + fdata.d2_.push_back(tcol + instance.d2.extent + 2); + std::get<0>(fdata.atts_).push_back(att++); + + // then begin a new data tile "Tnext" which straddles the bounds of that + // space tile. this will have a low MBR. + fdata.d1_.push_back(trow + instance.d1.extent - 1); + fdata.d2_.push_back(tcol + instance.d2.extent + 3); + std::get<0>(fdata.atts_).push_back(att++); + fdata.d1_.push_back(trow); + fdata.d2_.push_back(tcol + 2 * instance.d2.extent); + std::get<0>(fdata.atts_).push_back(att++); + + // then add a point P which is less than the lower bound of Tnext's MBR, + // and also between the last two coordinates of T + FxRun2D::FragmentType fpoint; + fpoint.d1_.push_back(trow + instance.d1.extent - 1); + fpoint.d2_.push_back(tcol + instance.d1.extent + 1); + std::get<0>(fpoint.atts_).push_back(att++); + + instance.fragments.push_back(fdata); + instance.fragments.push_back(fpoint); + } + + run(instance); + }; + + SECTION("Example") { + doit.operator()( + TILEDB_ROW_MAJOR, TILEDB_ROW_MAJOR, 4, 1024, 1, 4, false); + } + + SECTION("Rapidcheck") { + rc::prop("rapidcheck fragment skew", [doit]() { + const auto tile_order = + *rc::gen::element(TILEDB_ROW_MAJOR, TILEDB_COL_MAJOR); + const auto cell_order = + *rc::gen::element(TILEDB_ROW_MAJOR, TILEDB_COL_MAJOR); + const size_t approximate_memory_tiles = *rc::gen::inRange(2, 64); + const size_t num_user_cells = *rc::gen::inRange(1, 1024); + const size_t num_fragments = *rc::gen::inRange(1, 8); + const size_t tile_capacity = *rc::gen::inRange(1, 16); + const bool allow_dups = *rc::gen::arbitrary(); + const auto subarray = *rc::make_subarray_2d( + templates::Domain(1, 200), templates::Domain(1, 200)); + doit.operator()( + tile_order, + cell_order, + approximate_memory_tiles, + num_user_cells, + num_fragments, + tile_capacity, + allow_dups, + subarray); + }); + } +} + TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: tile offsets budget exceeded", @@ -2691,8 +2842,12 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { "fragments in global order") != std::string::npos) { if (!vfs_test_setup_.is_rest()) { // skip for REST since we will not have access to tile sizes - ASSERTER(!can_complete_in_memory_budget( - context(), array_name_.c_str(), instance)); + const auto can_complete = + can_complete_in_memory_budget( + context(), array_name_.c_str(), instance); + if (can_complete.has_value()) { + ASSERTER(!can_complete.value()); + } } tiledb_query_free(&query); return; @@ -2777,8 +2932,11 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { // lastly, check the correctness of our memory budgeting function // (skip for REST since we will not have access to tile sizes) if (!vfs_test_setup_.is_rest()) { - ASSERTER(can_complete_in_memory_budget( - context(), array_name_.c_str(), instance)); + const auto can_complete = can_complete_in_memory_budget( + context(), array_name_.c_str(), instance); + if (can_complete.has_value()) { + ASSERTER(can_complete.has_value()); + } } } From 13d69971c783bd695e1634fd3ef6e32f6294b243 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 17 Jan 2025 22:41:49 -0500 Subject: [PATCH 164/228] Fix invalid merge bound and duplicate coord corner case --- .../readers/sparse_global_order_reader.cc | 212 +++++++++--------- .../readers/sparse_global_order_reader.h | 4 +- 2 files changed, 111 insertions(+), 105 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index dd82f29b0c7..afb828c6f78 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -126,51 +126,6 @@ struct PreprocessTileMergeFuture { } }; -/** - * Holds the "merge bound" of the globally ordered stream. - * - * The "merge bound" is the largest known coordinate which - * is guaranteed to appear in the global order prior to - * any of the coordinates in yet-to-be-loaded tiles. - * - * See `preprocess_compute_tile_order`. - * - * The `merge_bound` may be derived from a coordinate - * value in a loaded tile, or from the MBR of a - * yet-to-be-loaded tile. - */ -struct PreprocessTileMergeBound { - PreprocessTileMergeBound(unsigned fragment_idx) - : fragment_idx_(fragment_idx) { - } - - unsigned fragment_idx_; - - std::optional tile_; - std::optional mbr_; - - const void* coord(unsigned d) const { - if (tile_.has_value()) { - return (*tile_)->coord((*tile_)->cell_num() - 1, d); - } else { - return mbr_.value().coord(d); - } - } - - UntypedDatumView dimension_datum(const Dimension& dim, unsigned d) const { - if (tile_.has_value()) { - if (dim.var_size()) { - return UntypedDatumView( - (*tile_)->coord_string((*tile_)->cell_num() - 1, d)); - } else { - return UntypedDatumView{coord(d), dim.coord_size()}; - } - } else { - return mbr_.value().dimension_datum(dim, d); - } - } -}; - /* ****************************** */ /* CONSTRUCTORS */ /* ****************************** */ @@ -580,35 +535,47 @@ bool SparseGlobalOrderReader::add_result_tile( * However, the coordinates would still be in global order *for each fragment*. * The parallel merge algorithm does not re-order the items of its lists. * - * How do we resolve this? Let's say we have identified a run of N tiles - * which fit in the memory budget, which come from arbitrary fragments, - * and are ordered by their MBR. + * How do we resolve this? + * + * If all of the tiles fit in memory, it is resolved trivially: + * the MBRs are just used to determine what order to load tiles in. + * Once all the tiles are loaded we use the actual coordinate values. * - * Without loading tile N+1, we do not know where the coordinates from - * tiles [1..N] fall in the global order with respect to the coordinates - * from tile N+1. But because the tiles from the same fragment *are* - * ordered, if one of the tiles in [1..N] (say M) is from the same fragment - * as tile N+1, then the max coordinate of tile M can be used as - * a "merge bound", i.e. any coordinates exceeding the bound cannot be - * merged. + * If not all of the tiles fit in memory, then each iteration we identify a + * bisection of the remaining tiles. Let's say tiles [0.. K] fit within the + * memory budget and we load the coordinates, and let's say tiles [K.. N] cannot + * be loaded and thus we can only access their MBRs via fragment metadata. * - * (FIXME: this is likely wrong, because there might be tiles from - * another fragment whose lower bound is greater than that of - * tile N+1 but contain coordinates less than the upper bound of M, - * write a test for this) + * If we select a tile in 0 <= A < K, and a tile in K <= B < N: + * (1) + * If A and B are in the same fragment, then all of the coordinates + * of A arrive before all of the coordinates of B. + * (2) + * If A and B are from different fragments, but there is any tile + * in 0 <= C < K which is from the same fragment as B, then all of + * the coordinates from A which are bounded by a coordinate in C + * are also bounded by coordinates in B. + * (3) + * If A and B are from different fragments, but there is no tile + * in 0 <= C < K which is from the same fragment as B, then we + * can infer no relationship whatsoever between the coordinates of + * A and the coordinates of B. * - * What if there is no tile in [1..N] from the same fragment as N+1? - * In this case, the MBR of tile N+1 is still a lower bound on what - * the coordinate values from tile N+1 can be, so we can use that - * as the merge bound. + * (2) and (3) demonstrate that it is not always correct to emit + * all of the coordinates of A prior to loading B. * - * In both cases, if emitting coordinates up to the merge bound does - * not exhaust a tile and free memory, then the query cannot proceed - * and returns an error to the user requesting more memory budget. + * If all the fragments have at least one tile in 0 <= A < K, then we + * can avoid out-of-order coordinates by fetching more tiles + * once we exhaust all of the coordinates from the first fragment + * which has tiles in K <= B < N. * - * And if there is no tile N+1 because there are no more tiles, - * then there is no merge bound and all coordinates can safely - * be emitted! + * If there is at least one fragment F which does not have a tile in 0 <= A < K, + * then we must construct a "merge bound" which is an upper bound on the + * coordinates which are guaranteed to be ordered correctly with respect to the + * coordinates in F. This value does not have to be an actual coordinate, just + * a lower bound on what coordinates are possible. The MBR of the first + * not-loaded tile of F is an easy and correct choice as it is guaranteed to be + * the lower bound of all coordinates in F. * * @precondition the `TempReadState` is up to date with which tiles pass the * subarray (e.g. by calling `load_initial_data`) @@ -685,6 +652,10 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( } } + if (fragment_result_tiles[f].empty()) { + tmp_read_state_.set_all_tiles_loaded(f); + } + return Status::Ok(); }; @@ -978,7 +949,6 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( std::vector& result_tiles, std::optional& merge_future) { // For easy reference. - const auto num_fragments = fragment_metadata_.size(); const auto num_dims = array_schema_.dim_num(); if (preprocess_tile_order_.has_more_tiles()) { @@ -1053,24 +1023,37 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( break; } } + rt++; } // update position for next iteration preprocess_tile_order_.cursor_ = rt; + // update which fragments are done + for (const auto& f : subarray_.relevant_fragments()) { + if (!tmp_read_state_.all_tiles_loaded(f)) { + bool all_tiles_loaded = true; + for (uint64_t ri = rt; + all_tiles_loaded && ri < preprocess_tile_order_.num_tiles_; + ri++) { + const auto& tile = preprocess_tile_order_.tiles_[ri]; + if (tile.fragment_idx_ == f) { + all_tiles_loaded = false; + break; + } + } + if (all_tiles_loaded) { + tmp_read_state_.set_all_tiles_loaded(f); + } + } + } + if (!preprocess_tile_order_.has_more_tiles()) { // TODO: original version sets a flag in tmp_read_state_ on a per-fragment // basis, does that have any effect other than computing this? read_state_.set_done_adding_result_tiles(true); - // TODO: would we gain anything from being more precise by checking - // which fragments have nothing remaining in the preprocess list - // in the general case? - for (unsigned f = 0; f < num_fragments; f++) { - tmp_read_state_.set_all_tiles_loaded(f); - } - // NB: merge must have completed for this condition to be satisfied const auto num_tiles = preprocess_tile_order_.tiles_.size(); preprocess_tile_order_.tiles_.clear(); @@ -1348,7 +1331,7 @@ AddNextCellResult SparseGlobalOrderReader::add_next_cell_to_queue( const std::vector& result_tiles, TileMinHeap& tile_queue, std::vector& to_delete, - const std::optional& merge_bound) { + const std::optional& merge_bound) { auto frag_idx = rc.tile_->frag_idx(); auto dups = array_schema_.allows_dups(); @@ -1415,7 +1398,7 @@ AddNextCellResult SparseGlobalOrderReader::add_next_cell_to_queue( // We can skip the comparison if the merge bound fragment is the same // as the current fragment because that is enough to tell us that // the coordinates are in order. - if (merge_bound.has_value() && merge_bound->fragment_idx_ != frag_idx) { + if (merge_bound.has_value()) { GlobalCellCmp cmp(array_schema_.domain()); if (cmp(*merge_bound, rc)) { // more tiles needed, out-of-order tiles is a possibility if we @@ -1535,25 +1518,41 @@ SparseGlobalOrderReader::merge_result_cell_slabs( std::vector rt_it(result_tiles.size()); // For preprocess tile order, compute the merge bound - std::optional merge_bound; + // (see comment in preprocess_compute_result_tile_order) + std::optional merge_bound; if (preprocess_tile_order_.has_more_tiles()) { - const auto& next_global_order_tile = - preprocess_tile_order_.tiles_[preprocess_tile_order_.cursor_]; - const auto f = next_global_order_tile.fragment_idx_; - - merge_bound.emplace(f); + auto has_pending_tiles = [&](uint64_t f) -> bool { + return result_tiles[f].empty() && !tmp_read_state_.all_tiles_loaded(f); + }; + bool any_pending_fragments = false; + for (const auto& f : subarray_.relevant_fragments()) { + if (has_pending_tiles(f)) { + any_pending_fragments = true; + break; + } + } - if (result_tiles[f].empty()) { - // use the MBR of the next tile - const auto& mbr = - fragment_metadata_[f]->mbr(next_global_order_tile.tile_idx_); - merge_bound->mbr_.emplace(RangeLowerBound{.mbr = mbr}); - } else { - // use the maximum known coordinate of this fragment - merge_bound->tile_.emplace(&result_tiles[f].back()); + if (any_pending_fragments) { + for (uint64_t rt = preprocess_tile_order_.cursor_; + rt < preprocess_tile_order_.num_tiles_; + rt++) { + const auto frt = preprocess_tile_order_.tiles_[rt].fragment_idx_; + if (has_pending_tiles(frt)) { + merge_bound.emplace(RangeLowerBound{ + .mbr = fragment_metadata_[frt]->mbr( + preprocess_tile_order_.tiles_[rt].tile_idx_)}); + break; + } + } } } + auto push_result = [&add_next_cell_result](auto res) { + if (add_next_cell_result != AddNextCellResult::NeedMoreTiles) { + add_next_cell_result = res; + } + }; + // For all fragments, get the first tile in the sorting queue. std::vector to_delete; throw_if_not_ok(parallel_for( @@ -1572,9 +1571,7 @@ SparseGlobalOrderReader::merge_result_cell_slabs( rc, rt_it, result_tiles, tile_queue, to_delete, merge_bound); { std::unique_lock ul(tile_queue_mutex_); - if (res == AddNextCellResult::NeedMoreTiles) { - add_next_cell_result = res; - } + push_result(res); } } @@ -1647,19 +1644,24 @@ SparseGlobalOrderReader::merge_result_cell_slabs( tile_queue.pop(); // Put the next cell from the processed tile in the queue. - add_next_cell_result = add_next_cell_to_queue( - to_remove, rt_it, result_tiles, tile_queue, to_delete, merge_bound); + push_result(add_next_cell_to_queue( + to_remove, + rt_it, + result_tiles, + tile_queue, + to_delete, + merge_bound)); } else { update_frag_idx(tile, to_process.pos_ + 1); // Put the next cell from the processed tile in the queue. - add_next_cell_result = add_next_cell_to_queue( + push_result(add_next_cell_to_queue( to_process, rt_it, result_tiles, tile_queue, to_delete, - merge_bound); + merge_bound)); to_process = tile_queue.top(); tile_queue.pop(); @@ -1705,7 +1707,11 @@ SparseGlobalOrderReader::merge_result_cell_slabs( length = to_process.max_slab_length(tile_queue.top(), cmp); } } else { - if (tile_queue.empty()) { + if (add_next_cell_result == AddNextCellResult::NeedMoreTiles) { + // e.g. because we were hitting duplicate coords and reached + // the end of a tile while de-duplicating + length = 1; + } else if (tile_queue.empty()) { length = to_process.max_slab_length(); } else { length = to_process.max_slab_length( @@ -1761,8 +1767,8 @@ SparseGlobalOrderReader::merge_result_cell_slabs( } // Put the next cell in the queue. - add_next_cell_result = add_next_cell_to_queue( - to_process, rt_it, result_tiles, tile_queue, to_delete, merge_bound); + push_result(add_next_cell_to_queue( + to_process, rt_it, result_tiles, tile_queue, to_delete, merge_bound)); } user_buffers_full = num_cells == 0; diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index 4daa5e7b64c..10ae70f57b8 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -52,7 +52,7 @@ namespace tiledb::sm { class Array; struct PreprocessTileMergeFuture; -struct PreprocessTileMergeBound; +struct RangeLowerBound; enum class AddNextCellResult { // finished the current tile @@ -404,7 +404,7 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, const std::vector& result_tiles, TileMinHeap& tile_queue, std::vector& to_delete, - const std::optional& merge_bound); + const std::optional& merge_bound); /** * Computes a tile's Hilbert values for a tile. From bf8dda700b71a874fbd431f46f54c27b465ac053 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 20 Jan 2025 09:16:00 -0500 Subject: [PATCH 165/228] if constexpr --- test/src/unit-sparse-global-order-reader.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 7cf0c829df4..da815cd8d0e 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -889,7 +889,7 @@ int32_t CSparseGlobalOrderFx::read_strings( template static std::optional can_complete_in_memory_budget( tiledb_ctx_t* ctx, const char* array_uri, const Instance& instance) { - if (std::tuple_size_v > 1) { + if constexpr (std::tuple_size_v > 1) { // don't even bother return std::nullopt; } From 145f381e905c84ab48f5de182f919011996ece53 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 20 Jan 2025 11:03:27 -0500 Subject: [PATCH 166/228] Move config access result into variable --- tiledb/sm/query/readers/sparse_global_order_reader.cc | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index afb828c6f78..cb3a5e81151 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -149,12 +149,11 @@ SparseGlobalOrderReader::SparseGlobalOrderReader( // Initialize memory budget variables. refresh_config(); + const auto preprocess_tile_merge_min_items = config_.get( + "sm.query.sparse_global_order.preprocess_tile_merge"); preprocess_tile_order_.enabled_ = array_schema_.cell_order() != Layout::HILBERT && - 0 < config_ - .get( - "sm.query.sparse_global_order.preprocess_tile_merge") - .value_or(0); + 0 < preprocess_tile_merge_min_items.value_or(0); preprocess_tile_order_.cursor_ = 0; preprocess_tile_order_.num_tiles_ = 1; // will be adjusted later if needed From 34e4473a2bfebbd275994b0f61aebbcea5e37848 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 20 Jan 2025 11:03:39 -0500 Subject: [PATCH 167/228] Deserialize set config before constructing strategy --- tiledb/sm/serialization/query.cc | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/tiledb/sm/serialization/query.cc b/tiledb/sm/serialization/query.cc index 4bd6904b7fc..22e48beeea0 100644 --- a/tiledb/sm/serialization/query.cc +++ b/tiledb/sm/serialization/query.cc @@ -1587,6 +1587,16 @@ Status query_from_capnp( "Cannot deserialize; array pointer is null.")); } + // Deserialize Config + if (query_reader.hasConfig()) { + tdb_unique_ptr decoded_config = nullptr; + auto config_reader = query_reader.getConfig(); + RETURN_NOT_OK(config_from_capnp(config_reader, &decoded_config)); + if (decoded_config != nullptr) { + query->unsafe_set_config(*decoded_config); + } + } + // Deserialize query type (sanity check). auto type = query->type(); QueryType query_type = QueryType::READ; @@ -1631,16 +1641,6 @@ Status query_from_capnp( // fully-initialized Query until the final QueryStatus is deserialized. query->set_status(QueryStatus::UNINITIALIZED); - // Deserialize Config - if (query_reader.hasConfig()) { - tdb_unique_ptr decoded_config = nullptr; - auto config_reader = query_reader.getConfig(); - RETURN_NOT_OK(config_from_capnp(config_reader, &decoded_config)); - if (decoded_config != nullptr) { - query->unsafe_set_config(*decoded_config); - } - } - // It's important that deserialization of query channels/aggregates happens // before deserializing buffers. set_data_buffer won't know whether a buffer // is aggregate or not if the list of aggregates per channel is not populated. From b6a4f180d0e80646454e61a5f221a5e59304780d Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 20 Jan 2025 15:07:56 -0500 Subject: [PATCH 168/228] Sprinkle some TRY into tests --- test/src/unit-capi-incomplete.cc | 6 ++++-- test/src/unit-capi-sparse_array.cc | 6 ++++-- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/test/src/unit-capi-incomplete.cc b/test/src/unit-capi-incomplete.cc index d45b02692f3..453cf086954 100644 --- a/test/src/unit-capi-incomplete.cc +++ b/test/src/unit-capi-incomplete.cc @@ -31,6 +31,7 @@ */ #include +#include "test/support/src/error_helpers.h" #include "test/support/src/helpers.h" #include "test/support/src/vfs_helpers.h" #include "tiledb/sm/c_api/tiledb.h" @@ -42,6 +43,8 @@ using namespace tiledb::test; +using Asserter = tiledb::test::AsserterCatch; + /** * Tests cases where a read query is incomplete or leads to a buffer * overflow. @@ -238,8 +241,7 @@ void IncompleteFx::create_sparse_array() { CHECK(rc == TILEDB_OK); // Create array - rc = tiledb_array_create(ctx_, sparse_array_uri_.c_str(), array_schema); - CHECK(rc == TILEDB_OK); + TRY(ctx_, tiledb_array_create(ctx_, sparse_array_uri_.c_str(), array_schema)); // Clean up tiledb_attribute_free(&a1); diff --git a/test/src/unit-capi-sparse_array.cc b/test/src/unit-capi-sparse_array.cc index b3d68d0e7b2..9494fc20145 100644 --- a/test/src/unit-capi-sparse_array.cc +++ b/test/src/unit-capi-sparse_array.cc @@ -37,6 +37,7 @@ #endif #include +#include "test/support/src/error_helpers.h" #include "test/support/src/helpers.h" #include "test/support/src/vfs_helpers.h" #ifdef _WIN32 @@ -61,6 +62,8 @@ using namespace tiledb::test; +using Asserter = tiledb::test::AsserterCatch; + const uint64_t DIM_DOMAIN[4] = {1, 4, 1, 4}; struct SparseArrayFx { @@ -3380,8 +3383,7 @@ TEST_CASE_METHOD( CHECK(coords_dim2[1] == 4); } - rc = tiledb_query_submit(ctx_, query); - CHECK(rc == TILEDB_OK); + TRY(ctx_, tiledb_query_submit(ctx_, query)); rc = tiledb_query_get_status(ctx_, query, &status); REQUIRE(rc == TILEDB_OK); REQUIRE(status == TILEDB_COMPLETED); From 2846673a62821878d57c5b6876a4e3a54862661c Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 20 Jan 2025 15:31:01 -0500 Subject: [PATCH 169/228] Compute fragments done even when no more tiles, for REST --- .../readers/sparse_global_order_reader.cc | 42 +++++++++---------- 1 file changed, 19 insertions(+), 23 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index cb3a5e81151..ae85b3608c3 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -1029,36 +1029,32 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( // update position for next iteration preprocess_tile_order_.cursor_ = rt; - // update which fragments are done - for (const auto& f : subarray_.relevant_fragments()) { - if (!tmp_read_state_.all_tiles_loaded(f)) { - bool all_tiles_loaded = true; - for (uint64_t ri = rt; - all_tiles_loaded && ri < preprocess_tile_order_.num_tiles_; - ri++) { - const auto& tile = preprocess_tile_order_.tiles_[ri]; - if (tile.fragment_idx_ == f) { - all_tiles_loaded = false; - break; - } - } - if (all_tiles_loaded) { - tmp_read_state_.set_all_tiles_loaded(f); - } - } - } - if (!preprocess_tile_order_.has_more_tiles()) { - // TODO: original version sets a flag in tmp_read_state_ on a per-fragment - // basis, does that have any effect other than computing this? - read_state_.set_done_adding_result_tiles(true); - // NB: merge must have completed for this condition to be satisfied const auto num_tiles = preprocess_tile_order_.tiles_.size(); preprocess_tile_order_.tiles_.clear(); memory_used_for_coords_total_ -= sizeof(ResultTileId) * num_tiles; } } + + // update which fragments are done + for (const auto& f : subarray_.relevant_fragments()) { + if (!tmp_read_state_.all_tiles_loaded(f)) { + bool all_tiles_loaded = true; + for (uint64_t ri = preprocess_tile_order_.cursor_; + all_tiles_loaded && ri < preprocess_tile_order_.num_tiles_; + ri++) { + const auto& tile = preprocess_tile_order_.tiles_[ri]; + if (tile.fragment_idx_ == f) { + all_tiles_loaded = false; + break; + } + } + if (all_tiles_loaded) { + tmp_read_state_.set_all_tiles_loaded(f); + } + } + } } template From 934672b5892ba440db1da13ec2c28db583aba16c Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 20 Jan 2025 22:03:36 -0500 Subject: [PATCH 170/228] Change test name to make it unique --- test/src/unit-capi-incomplete.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/src/unit-capi-incomplete.cc b/test/src/unit-capi-incomplete.cc index 453cf086954..62a2b283c18 100644 --- a/test/src/unit-capi-incomplete.cc +++ b/test/src/unit-capi-incomplete.cc @@ -1181,7 +1181,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( IncompleteFx, - "C API: Test incomplete read queries, sparse", + "C API: Test incomplete read queries, sparse force retry", "[capi][incomplete][sparse][retries][sc-49128][rest]") { // This test is testing CURL logic and only makes sense on REST-CI if (!vfs_test_setup_.is_rest()) { From 5e246dce86d8807b0a71d8d3f17f2368ac4ea2ed Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 20 Jan 2025 22:05:04 -0500 Subject: [PATCH 171/228] REST server populate result tiles from previous iterations --- .../readers/sparse_global_order_reader.cc | 113 ++++++++++++++++-- 1 file changed, 105 insertions(+), 8 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index ae85b3608c3..7abe9a1114d 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -118,6 +118,30 @@ struct PreprocessTileMergeFuture { return ret; } + /** + * Waits for the merge to have completed up to the requested `cursor`. + * + * @return true if the requested cursor is available, false otherwise + */ + bool wait_for(uint64_t cursor) { + if (!merge_.has_value()) { + return true; + } + + std::optional bound = merge_.value()->valid_output_bound(); + if (bound.has_value() && bound.value() >= cursor) { + return true; + } + + while ((bound = merge_.value()->await()).has_value()) { + if (bound.value() >= cursor) { + return true; + } + } + + return false; + } + void block() { if (merge_.has_value()) { merge_.value()->block(); @@ -237,8 +261,14 @@ Status SparseGlobalOrderReader::dowork() { // (this happens after load_initial_data which identifies which tiles pass // subarray) std::optional preprocess_future; - if (preprocess_tile_order_.has_more_tiles() && + if (preprocess_tile_order_.enabled_ && preprocess_tile_order_.tiles_.empty()) { + // For native, this only happens in the first dowork(), then the merged + // tile list remains in memory. + // For REST, this happens in each submit() call. We assume that the merge + // is cheaper than serializing the list. This is necessary even if + // `preprocess_tile_order_.cursor_ == preprocess_tile_order_num_tiles_` + // because we need to keep track of partially-used result tiles. preprocess_future.emplace(memory_used_for_coords_total_); preprocess_compute_result_tile_order(preprocess_future.value()); } @@ -950,6 +980,73 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( // For easy reference. const auto num_dims = array_schema_.dim_num(); + if (preprocess_tile_order_.cursor_ > 0 && + std::all_of(result_tiles.begin(), result_tiles.end(), [](const auto& r) { + return r.empty(); + })) { + // When a result tile is created for a ResultTileId, the preprocess merge + // cursor advances. Then the result tile tracks how much data has been + // emitted from that tile. + // + // When running natively, if an iteration does not exhaust that result tile + // remains in the result tile list and its cursor remains in memory for + // use in the next iteration. + // + // When running against the REST server, if an iteration does not exhaust a + // result tile, then its cursor must be serialized/deserialized. That state + // lives in `read_state_.frag_idx()`. + // + // Hence if we have no result tiles, and a preprocess cursor, then we must + // check if we have any un-exhausted result tiles. + const auto& rtcursors = read_state_.frag_idx(); + + for (const auto& f : subarray_.relevant_fragments()) { + if (merge_future.has_value()) { + const bool wait_ok = + merge_future->wait_for(preprocess_tile_order_.cursor_); + assert(wait_ok); + } + + // identify the tiles in reverse global order + std::vector rts; + for (size_t rti = preprocess_tile_order_.cursor_; rti > 0; --rti) { + const auto& rt = preprocess_tile_order_.tiles_[rti - 1]; + if (rt.fragment_idx_ != f) { + continue; + } else if (rtcursors[f].tile_idx_ > rt.tile_idx_) { + // all of the tiles for this fragment up to this are done + break; + } + + rts.push_back(rti - 1); + } + + // and then re-create them + for (auto rti = rts.rbegin(); rti != rts.rend(); ++rti) { + const auto& rt = preprocess_tile_order_.tiles_[*rti]; + + // this is a tile which qualified for the subarray and was + // a created result tile, we must continue processing it + const auto budget_exceeded = add_result_tile( + num_dims, f, rt.tile_idx_, *fragment_metadata_[f], result_tiles); + + // all these tiles were created in a previous iteration, so we *had* + // the memory budget - and must not any more. Can a user change + // configuration between rounds of `tiledb_query_submit`? If + // not then this represents internal error; if so then this + // represents user error. Since we have lost the ordering of tiles, + // we have to fall back to "per fragment" mode which is achievable + // but too complicated for this author to want to bother. + if (budget_exceeded) { + throw SparseGlobalOrderReaderException( + "Cannot load result tiles from previous submit: this likely " + "indicates a reduction in memory budget. Increase memory " + "budget."); + } + } + } + } + if (preprocess_tile_order_.has_more_tiles()) { size_t rt = preprocess_tile_order_.cursor_; size_t rt_merge_bound = @@ -1028,13 +1125,6 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( // update position for next iteration preprocess_tile_order_.cursor_ = rt; - - if (!preprocess_tile_order_.has_more_tiles()) { - // NB: merge must have completed for this condition to be satisfied - const auto num_tiles = preprocess_tile_order_.tiles_.size(); - preprocess_tile_order_.tiles_.clear(); - memory_used_for_coords_total_ -= sizeof(ResultTileId) * num_tiles; - } } // update which fragments are done @@ -1055,6 +1145,13 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( } } } + + if (!preprocess_tile_order_.has_more_tiles()) { + // NB: merge must have completed for this condition to be satisfied + const auto num_tiles = preprocess_tile_order_.tiles_.size(); + preprocess_tile_order_.tiles_.clear(); + memory_used_for_coords_total_ -= sizeof(ResultTileId) * num_tiles; + } } template From a7847873c1f06397e5298cc488ee749c66b5f750 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 21 Jan 2025 11:54:53 -0500 Subject: [PATCH 172/228] Fix REQUIRE => ASSERTER --- test/src/unit-sparse-global-order-reader.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index da815cd8d0e..0ad2d38d163 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2879,7 +2879,7 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { } outcursor += dim_num_cells; - REQUIRE(outcursor <= expect.size()); + ASSERTER(outcursor <= expect.size()); if (status == TILEDB_COMPLETED) { break; From 361b8cd2332afd5a0371c55c8f37a2d11be7723f Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 21 Jan 2025 11:57:43 -0500 Subject: [PATCH 173/228] Switch to serialize tile order --- .../readers/sparse_global_order_reader.cc | 63 +++-- .../readers/sparse_global_order_reader.h | 2 +- .../query/readers/sparse_index_reader_base.cc | 2 +- .../query/readers/sparse_index_reader_base.h | 10 +- tiledb/sm/serialization/query.cc | 21 +- tiledb/sm/serialization/tiledb-rest.capnp | 14 +- tiledb/sm/serialization/tiledb-rest.capnp.c++ | 101 ++++++- tiledb/sm/serialization/tiledb-rest.capnp.h | 252 +++++++++++++++++- 8 files changed, 395 insertions(+), 70 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 7abe9a1114d..77a9230673c 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -179,7 +179,6 @@ SparseGlobalOrderReader::SparseGlobalOrderReader( array_schema_.cell_order() != Layout::HILBERT && 0 < preprocess_tile_merge_min_items.value_or(0); preprocess_tile_order_.cursor_ = 0; - preprocess_tile_order_.num_tiles_ = 1; // will be adjusted later if needed if (!preprocess_tile_order_.enabled_) { per_fragment_memory_state_.memory_used_for_coords_.resize( @@ -200,7 +199,10 @@ bool SparseGlobalOrderReader::incomplete() const { } else if (preprocess_tile_order_.has_more_tiles()) { return false; } else { - return memory_used_for_coords_total_ != 0; + [[maybe_unused]] const size_t mem_for_tile_order = + sizeof(ResultTileId) * preprocess_tile_order_.tiles_.size(); + assert(memory_used_for_coords_total_ >= mem_for_tile_order); + return memory_used_for_coords_total_ > mem_for_tile_order; } } @@ -222,13 +224,13 @@ void SparseGlobalOrderReader::refresh_config() { template void SparseGlobalOrderReader::set_preprocess_tile_order_cursor( - uint64_t cursor, uint64_t num_tiles) { + uint64_t cursor, std::vector tiles) { preprocess_tile_order_.enabled_ = true; preprocess_tile_order_.cursor_ = cursor; - preprocess_tile_order_.num_tiles_ = num_tiles; + preprocess_tile_order_.tiles_ = tiles; - // The tile order itself will be recomputed if needed. - // We get smaller messages but at a higher CPU cost. + memory_used_for_coords_total_ += + sizeof(ResultTileId) * preprocess_tile_order_.tiles_.size(); } template @@ -263,14 +265,18 @@ Status SparseGlobalOrderReader::dowork() { std::optional preprocess_future; if (preprocess_tile_order_.enabled_ && preprocess_tile_order_.tiles_.empty()) { - // For native, this only happens in the first dowork(), then the merged - // tile list remains in memory. - // For REST, this happens in each submit() call. We assume that the merge - // is cheaper than serializing the list. This is necessary even if - // `preprocess_tile_order_.cursor_ == preprocess_tile_order_num_tiles_` - // because we need to keep track of partially-used result tiles. + // For native, this should only happen in the first `tiledb_query_submit`, + // then the merged list remains in memory until the end is reached. + // For REST, this happens in the first `submit` call; then the tiles + // are serialized back and forth; and then this happens again once the + // end of the list is reached (at which point it is cleared), if more + // iterations are needed. preprocess_future.emplace(memory_used_for_coords_total_); preprocess_compute_result_tile_order(preprocess_future.value()); + } else if (preprocess_tile_order_.enabled_) { + // NB: we could have avoided loading these in the first place + // since we already have determined which tiles qualify, and their order + tmp_read_state_.clear_tile_ranges(); } purge_deletes_consolidation_ = !deletes_consolidation_no_purge_ && @@ -713,7 +719,6 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( } /* then do parallel merge */ - preprocess_tile_order_.num_tiles_ = num_result_tiles; preprocess_tile_order_.tiles_.resize( num_result_tiles, ResultTileId{.fragment_idx_ = 0, .tile_idx_ = 0}); @@ -1000,13 +1005,16 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( // check if we have any un-exhausted result tiles. const auto& rtcursors = read_state_.frag_idx(); - for (const auto& f : subarray_.relevant_fragments()) { - if (merge_future.has_value()) { - const bool wait_ok = - merge_future->wait_for(preprocess_tile_order_.cursor_); - assert(wait_ok); + if (merge_future.has_value()) { + const bool wait_ok = + merge_future->wait_for(preprocess_tile_order_.cursor_); + if (!wait_ok) { + throw SparseGlobalOrderReaderInternalError( + "Waiting for preprocess tile merge results failed"); } + } + for (const auto& f : subarray_.relevant_fragments()) { // identify the tiles in reverse global order std::vector rts; for (size_t rti = preprocess_tile_order_.cursor_; rti > 0; --rti) { @@ -1132,7 +1140,7 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( if (!tmp_read_state_.all_tiles_loaded(f)) { bool all_tiles_loaded = true; for (uint64_t ri = preprocess_tile_order_.cursor_; - all_tiles_loaded && ri < preprocess_tile_order_.num_tiles_; + all_tiles_loaded && ri < preprocess_tile_order_.tiles_.size(); ri++) { const auto& tile = preprocess_tile_order_.tiles_[ri]; if (tile.fragment_idx_ == f) { @@ -1145,13 +1153,6 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( } } } - - if (!preprocess_tile_order_.has_more_tiles()) { - // NB: merge must have completed for this condition to be satisfied - const auto num_tiles = preprocess_tile_order_.tiles_.size(); - preprocess_tile_order_.tiles_.clear(); - memory_used_for_coords_total_ -= sizeof(ResultTileId) * num_tiles; - } } template @@ -1626,7 +1627,7 @@ SparseGlobalOrderReader::merge_result_cell_slabs( if (any_pending_fragments) { for (uint64_t rt = preprocess_tile_order_.cursor_; - rt < preprocess_tile_order_.num_tiles_; + rt < preprocess_tile_order_.tiles_.size(); rt++) { const auto frt = preprocess_tile_order_.tiles_[rt].fragment_idx_; if (has_pending_tiles(frt)) { @@ -2965,7 +2966,13 @@ void SparseGlobalOrderReader::end_iteration( })); if (!incomplete()) { - assert(memory_used_for_coords_total_ == 0); + if (preprocess_tile_order_.enabled_) { + [[maybe_unused]] const size_t mem_for_tile_order = + sizeof(ResultTileId) * preprocess_tile_order_.tiles_.size(); + assert(memory_used_for_coords_total_ == mem_for_tile_order); + } else { + assert(memory_used_for_coords_total_ == 0); + } assert(tmp_read_state_.memory_used_tile_ranges() == 0); } diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index 10ae70f57b8..69d4390c95a 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -138,7 +138,7 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, /** Used in deserialization */ virtual void set_preprocess_tile_order_cursor( - uint64_t cursor, uint64_t num_tiles) override; + uint64_t cursor, std::vector tiles) override; private: /* ********************************* */ diff --git a/tiledb/sm/query/readers/sparse_index_reader_base.cc b/tiledb/sm/query/readers/sparse_index_reader_base.cc index ea4c8bab65c..bec5d883bd2 100644 --- a/tiledb/sm/query/readers/sparse_index_reader_base.cc +++ b/tiledb/sm/query/readers/sparse_index_reader_base.cc @@ -143,7 +143,7 @@ const PreprocessTileOrder& SparseIndexReaderBase::preprocess_tile_order() } void SparseIndexReaderBase::set_preprocess_tile_order_cursor( - uint64_t, uint64_t) { + uint64_t, std::vector) { throw SparseIndexReaderBaseException( "Internal error: set_preprocess_tile_order_cursor for unsupported sparse " "index reader"); diff --git a/tiledb/sm/query/readers/sparse_index_reader_base.h b/tiledb/sm/query/readers/sparse_index_reader_base.h index 003e451039c..834cab67838 100644 --- a/tiledb/sm/query/readers/sparse_index_reader_base.h +++ b/tiledb/sm/query/readers/sparse_index_reader_base.h @@ -303,14 +303,8 @@ struct PreprocessTileOrder { size_t cursor_; std::vector tiles_; - // NB: looks redundant with tiles_.size() but - // we need to mark completeness without using tiles_ because: - // 1) for REST tiles_ is not serialized - // 2) tiles_ is cleared to release memory once it is done - size_t num_tiles_; - bool has_more_tiles() const { - return enabled_ && cursor_ < num_tiles_; + return enabled_ && cursor_ < tiles_.size(); } }; @@ -635,7 +629,7 @@ class SparseIndexReaderBase : public ReaderBase { * @param cursor New cursor value. */ virtual void set_preprocess_tile_order_cursor( - uint64_t cursor, uint64_t num_tiles); + uint64_t cursor, std::vector tiles); protected: /* ********************************* */ diff --git a/tiledb/sm/serialization/query.cc b/tiledb/sm/serialization/query.cc index 22e48beeea0..c7d992529f7 100644 --- a/tiledb/sm/serialization/query.cc +++ b/tiledb/sm/serialization/query.cc @@ -935,9 +935,16 @@ Status index_reader_to_capnp( // Tile order if (reader.preprocess_tile_order().enabled_) { + const auto& pstate = reader.preprocess_tile_order(); + auto preprocess = reader_builder->initPreprocess(); preprocess.setCursor(reader.preprocess_tile_order().cursor_); - preprocess.setNumTiles(reader.preprocess_tile_order().num_tiles_); + + auto tiles = preprocess.initTiles(pstate.tiles_.size()); + for (size_t t = 0; t < pstate.tiles_.size(); t++) { + tiles[t].setFragIdx(pstate.tiles_[t].fragment_idx_); + tiles[t].setTileIdx(pstate.tiles_[t].tile_idx_); + } } return Status::Ok(); @@ -1174,9 +1181,15 @@ Status index_reader_from_capnp( } if (reader_reader.hasPreprocess()) { - reader->set_preprocess_tile_order_cursor( - reader_reader.getPreprocess().getCursor(), - reader_reader.getPreprocess().getNumTiles()); + const auto& preproc = reader_reader.getPreprocess(); + std::vector tiles(preproc.getTiles().size()); + for (size_t t = 0; t < preproc.getTiles().size(); t++) { + tiles[t] = ResultTileId{ + .fragment_idx_ = preproc.getTiles()[t].getFragIdx(), + .tile_idx_ = preproc.getTiles()[t].getTileIdx(), + }; + } + reader->set_preprocess_tile_order_cursor(preproc.getCursor(), tiles); } return Status::Ok(); diff --git a/tiledb/sm/serialization/tiledb-rest.capnp b/tiledb/sm/serialization/tiledb-rest.capnp index 7625743d405..2dcd17d5ba3 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp +++ b/tiledb/sm/serialization/tiledb-rest.capnp @@ -670,6 +670,16 @@ struct Delete { # Stats object } +struct ResultTileId { +# Identifies a tile + + fragIdx @0 :UInt32; + # Fragment index + + tileIdx @1 :UInt64; + # Tile index +} + struct ResultCellSlab { # Result cell slab @@ -713,8 +723,8 @@ struct PreprocessTileOrder { cursor @0 :UInt64; # Position in the preprocess tile order list. - numTiles @1 :UInt64; - # Number of total tiles in the preprocess tile order list. + tiles @1 :List(ResultTileId); + # List of tiles arranged in the order they must be opened } struct ReaderIndex { diff --git a/tiledb/sm/serialization/tiledb-rest.capnp.c++ b/tiledb/sm/serialization/tiledb-rest.capnp.c++ index 7be151d3bc5..858729ad1f5 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp.c++ +++ b/tiledb/sm/serialization/tiledb-rest.capnp.c++ @@ -5222,6 +5222,65 @@ const ::capnp::_::RawSchema s_d74f5fed155d316c = { 2, 2, i_d74f5fed155d316c, nullptr, nullptr, { &s_d74f5fed155d316c, nullptr, nullptr, 0, 0, nullptr }, false }; #endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<48> b_afcbef694e73edb8 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 184, 237, 115, 78, 105, 239, 203, 175, + 18, 0, 0, 0, 1, 0, 2, 0, + 127, 216, 135, 181, 36, 146, 125, 181, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 250, 0, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 105, 108, 101, 100, 98, 45, 114, + 101, 115, 116, 46, 99, 97, 112, 110, + 112, 58, 82, 101, 115, 117, 108, 116, + 84, 105, 108, 101, 73, 100, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 3, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 102, 114, 97, 103, 73, 100, 120, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 105, 108, 101, 73, 100, 120, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +::capnp::word const* const bp_afcbef694e73edb8 = b_afcbef694e73edb8.words; +#if !CAPNP_LITE +static const uint16_t m_afcbef694e73edb8[] = {0, 1}; +static const uint16_t i_afcbef694e73edb8[] = {0, 1}; +const ::capnp::_::RawSchema s_afcbef694e73edb8 = { + 0xafcbef694e73edb8, b_afcbef694e73edb8.words, 48, nullptr, m_afcbef694e73edb8, + 0, 2, i_afcbef694e73edb8, nullptr, nullptr, { &s_afcbef694e73edb8, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE static const ::capnp::_::AlignedData<79> b_def87cead82188e7 = { { 0, 0, 0, 0, 5, 0, 6, 0, 231, 136, 33, 216, 234, 124, 248, 222, @@ -5462,12 +5521,12 @@ const ::capnp::_::RawSchema s_c86c77b5f6a2bf0f = { 2, 3, i_c86c77b5f6a2bf0f, nullptr, nullptr, { &s_c86c77b5f6a2bf0f, nullptr, nullptr, 0, 0, nullptr }, false }; #endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<50> b_818a8600b3452aa4 = { +static const ::capnp::_::AlignedData<53> b_818a8600b3452aa4 = { { 0, 0, 0, 0, 5, 0, 6, 0, 164, 42, 69, 179, 0, 134, 138, 129, - 18, 0, 0, 0, 1, 0, 2, 0, + 18, 0, 0, 0, 1, 0, 1, 0, 127, 216, 135, 181, 36, 146, 125, 181, - 0, 0, 7, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 0, 50, 1, 0, 0, 37, 0, 0, 0, 7, 0, 0, 0, @@ -5489,13 +5548,13 @@ static const ::capnp::_::AlignedData<50> b_818a8600b3452aa4 = { 0, 0, 0, 0, 0, 0, 0, 0, 36, 0, 0, 0, 3, 0, 1, 0, 48, 0, 0, 0, 2, 0, 1, 0, - 1, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 45, 0, 0, 0, 74, 0, 0, 0, + 45, 0, 0, 0, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 44, 0, 0, 0, 3, 0, 1, 0, - 56, 0, 0, 0, 2, 0, 1, 0, + 40, 0, 0, 0, 3, 0, 1, 0, + 68, 0, 0, 0, 2, 0, 1, 0, 99, 117, 114, 115, 111, 114, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5504,23 +5563,29 @@ static const ::capnp::_::AlignedData<50> b_818a8600b3452aa4 = { 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 110, 117, 109, 84, 105, 108, 101, 115, + 116, 105, 108, 101, 115, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 184, 237, 115, 78, 105, 239, 203, 175, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 9, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, } }; ::capnp::word const* const bp_818a8600b3452aa4 = b_818a8600b3452aa4.words; #if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_818a8600b3452aa4[] = { + &s_afcbef694e73edb8, +}; static const uint16_t m_818a8600b3452aa4[] = {0, 1}; static const uint16_t i_818a8600b3452aa4[] = {0, 1}; const ::capnp::_::RawSchema s_818a8600b3452aa4 = { - 0x818a8600b3452aa4, b_818a8600b3452aa4.words, 50, nullptr, m_818a8600b3452aa4, - 0, 2, i_818a8600b3452aa4, nullptr, nullptr, { &s_818a8600b3452aa4, nullptr, nullptr, 0, 0, nullptr }, false + 0x818a8600b3452aa4, b_818a8600b3452aa4.words, 53, d_818a8600b3452aa4, m_818a8600b3452aa4, + 1, 2, i_818a8600b3452aa4, nullptr, nullptr, { &s_818a8600b3452aa4, nullptr, nullptr, 0, 0, nullptr }, false }; #endif // !CAPNP_LITE static const ::capnp::_::AlignedData<112> b_9b9a5fc7713a8692 = { @@ -11277,6 +11342,18 @@ constexpr ::capnp::_::RawSchema const* Delete::_capnpPrivate::schema; #endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL #endif // !CAPNP_LITE +// ResultTileId +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t ResultTileId::_capnpPrivate::dataWordSize; +constexpr uint16_t ResultTileId::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind ResultTileId::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* ResultTileId::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + // ResultCellSlab #if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL constexpr uint16_t ResultCellSlab::_capnpPrivate::dataWordSize; diff --git a/tiledb/sm/serialization/tiledb-rest.capnp.h b/tiledb/sm/serialization/tiledb-rest.capnp.h index bf7e500e676..71412a61550 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp.h +++ b/tiledb/sm/serialization/tiledb-rest.capnp.h @@ -66,6 +66,7 @@ CAPNP_DECLARE_SCHEMA(afc739d5c01e6496); CAPNP_DECLARE_SCHEMA(eaf57cb9871fc06f); CAPNP_DECLARE_SCHEMA(e19754f813ccf79c); CAPNP_DECLARE_SCHEMA(d74f5fed155d316c); +CAPNP_DECLARE_SCHEMA(afcbef694e73edb8); CAPNP_DECLARE_SCHEMA(def87cead82188e7); CAPNP_DECLARE_SCHEMA(c1a2d010de779de5); CAPNP_DECLARE_SCHEMA(c86c77b5f6a2bf0f); @@ -980,6 +981,23 @@ struct Delete { }; }; +struct ResultTileId { + ResultTileId() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(afcbef694e73edb8, 2, 0) +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE + }; +}; + struct ResultCellSlab { ResultCellSlab() = delete; @@ -1039,7 +1057,7 @@ struct PreprocessTileOrder { class Pipeline; struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(818a8600b3452aa4, 2, 0) + CAPNP_DECLARE_STRUCT_HEADER(818a8600b3452aa4, 1, 1) #if !CAPNP_LITE static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; @@ -8826,6 +8844,103 @@ class Delete::Pipeline { }; #endif // !CAPNP_LITE +class ResultTileId::Reader { + public: + typedef ResultTileId Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base) + : _reader(base) { + } + + inline ::capnp::MessageSize totalSize() const { + return _reader.totalSize().asPublic(); + } + +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); + } +#endif // !CAPNP_LITE + + inline ::uint32_t getFragIdx() const; + + inline ::uint64_t getTileIdx() const; + + private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; +}; + +class ResultTileId::Builder { + public: + typedef ResultTileId Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) { + } + inline explicit Builder(::capnp::_::StructBuilder base) + : _builder(base) { + } + inline operator Reader() const { + return Reader(_builder.asReader()); + } + inline Reader asReader() const { + return *this; + } + + inline ::capnp::MessageSize totalSize() const { + return asReader().totalSize(); + } +#if !CAPNP_LITE + inline ::kj::StringTree toString() const { + return asReader().toString(); + } +#endif // !CAPNP_LITE + + inline ::uint32_t getFragIdx(); + inline void setFragIdx(::uint32_t value); + + inline ::uint64_t getTileIdx(); + inline void setTileIdx(::uint64_t value); + + private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class ResultTileId::Pipeline { + public: + typedef ResultTileId Pipelines; + + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) { + } + + private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + class ResultCellSlab::Reader { public: typedef ResultCellSlab Reads; @@ -9198,7 +9313,11 @@ class PreprocessTileOrder::Reader { inline ::uint64_t getCursor() const; - inline ::uint64_t getNumTiles() const; + inline bool hasTiles() const; + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>::Reader + getTiles() const; private: ::capnp::_::StructReader _reader; @@ -9242,8 +9361,25 @@ class PreprocessTileOrder::Builder { inline ::uint64_t getCursor(); inline void setCursor(::uint64_t value); - inline ::uint64_t getNumTiles(); - inline void setNumTiles(::uint64_t value); + inline bool hasTiles(); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>::Builder + getTiles(); + inline void setTiles(::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>::Reader value); + inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>::Builder + initTiles(unsigned int size); + inline void adoptTiles(::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>>&& value); + inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>> + disownTiles(); private: ::capnp::_::StructBuilder _builder; @@ -25540,6 +25676,34 @@ Delete::Builder::disownStats() { _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } +inline ::uint32_t ResultTileId::Reader::getFragIdx() const { + return _reader.getDataField<::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint32_t ResultTileId::Builder::getFragIdx() { + return _builder.getDataField<::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void ResultTileId::Builder::setFragIdx(::uint32_t value) { + _builder.setDataField<::uint32_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint64_t ResultTileId::Reader::getTileIdx() const { + return _reader.getDataField<::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::uint64_t ResultTileId::Builder::getTileIdx() { + return _builder.getDataField<::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void ResultTileId::Builder::setTileIdx(::uint64_t value) { + _builder.setDataField<::uint64_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + inline ::uint32_t ResultCellSlab::Reader::getFragIdx() const { return _reader.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); @@ -25797,18 +25961,78 @@ inline void PreprocessTileOrder::Builder::setCursor(::uint64_t value) { ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t PreprocessTileOrder::Reader::getNumTiles() const { - return _reader.getDataField<::uint64_t>( - ::capnp::bounded<1>() * ::capnp::ELEMENTS); +inline bool PreprocessTileOrder::Reader::hasTiles() const { + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } - -inline ::uint64_t PreprocessTileOrder::Builder::getNumTiles() { - return _builder.getDataField<::uint64_t>( - ::capnp::bounded<1>() * ::capnp::ELEMENTS); +inline bool PreprocessTileOrder::Builder::hasTiles() { + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); } -inline void PreprocessTileOrder::Builder::setNumTiles(::uint64_t value) { - _builder.setDataField<::uint64_t>( - ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>::Reader +PreprocessTileOrder::Reader::getTiles() const { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>>::get(_reader + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>::Builder +PreprocessTileOrder::Builder::getTiles() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>>::get(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); +} +inline void PreprocessTileOrder::Builder::setTiles( + ::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>::Reader value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>>:: + set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>::Builder +PreprocessTileOrder::Builder::initTiles(unsigned int size) { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>>:: + init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + size); +} +inline void PreprocessTileOrder::Builder::adoptTiles( + ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>>&& value) { + ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>>:: + adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>> +PreprocessTileOrder::Builder::disownTiles() { + return ::capnp::_::PointerHelpers<::capnp::List< + ::tiledb::sm::serialization::capnp::ResultTileId, + ::capnp::Kind::STRUCT>>::disown(_builder + .getPointerField( + ::capnp::bounded<0>() * + ::capnp::POINTERS)); } inline bool ReaderIndex::Reader::hasLayout() const { From c2a5bf4525e7ab94e32c509e8180e0d6842f884b Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 21 Jan 2025 11:58:57 -0500 Subject: [PATCH 174/228] Add some examples found by shrinking --- test/src/unit-sparse-global-order-reader.cc | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 0ad2d38d163..4394b21b18a 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -1303,6 +1303,13 @@ TEST_CASE_METHOD( doit.operator()(200, 8, 2); } + SECTION("Shrink") { + doit.operator()( + 2, 1, 1, {templates::Domain(1, 1)}); + doit.operator()( + 2, 1, 1, {templates::Domain(1, 2)}); + } + SECTION("Rapidcheck") { rc::prop("rapidcheck fragment skew", [doit]() { const size_t fragment_size = *rc::gen::inRange(2, 200); From d7caa66929a35e9ba71a2fc1d388bf61d1c1ed61 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 21 Jan 2025 15:54:52 -0500 Subject: [PATCH 175/228] Specialize rapidcheck showValue for optional --- test/support/stdx/optional.h | 52 +++++++++++++++++++++++++++++++++++ test/support/tdb_rapidcheck.h | 33 ++++++++++++++++++++++ 2 files changed, 85 insertions(+) create mode 100644 test/support/stdx/optional.h diff --git a/test/support/stdx/optional.h b/test/support/stdx/optional.h new file mode 100644 index 00000000000..3b51fd6cb4d --- /dev/null +++ b/test/support/stdx/optional.h @@ -0,0 +1,52 @@ +/** + * @file test/support/stdx/optional.h + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2025 TileDB, 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. + * + * @section DESCRIPTION + * + * This file defines functions for manipulating `std::optional`. + */ + +#ifndef TILEDB_TEST_SUPPORT_OPTIONAL_H +#define TILEDB_TEST_SUPPORT_OPTIONAL_H + +namespace stdx { + +template +struct is_optional { + static constexpr bool value = false; +}; + +template +struct is_optional> { + static constexpr bool value = true; +}; + +template +concept is_optional_v = is_optional::value; +} // namespace stdx + +#endif diff --git a/test/support/tdb_rapidcheck.h b/test/support/tdb_rapidcheck.h index 7e6d90a22bc..2f7907de580 100644 --- a/test/support/tdb_rapidcheck.h +++ b/test/support/tdb_rapidcheck.h @@ -41,8 +41,25 @@ * `CATCH_TEST_MACROS_HPP_INCLUDED` * which is the bridge between v2 and v3 compatibility for */ +#include #include +// forward declarations of `showValue` overloads +// (these must be declared prior to including `rapidcheck/Show.hpp` for some +// reason) +namespace rc { +namespace detail { + +/** + * Specializes `show` for `std::optional` to print the final test case after + * shrinking + */ +template +void showValue(const T& value, std::ostream& os); + +} // namespace detail +} // namespace rc + #include #include @@ -85,6 +102,22 @@ struct Arbitrary> { [](T inner) { return NonShrinking(std::move(inner)); }, inner); } }; + +namespace detail { + +template +void showValue(const T& value, std::ostream& os) { + if (value.has_value()) { + os << "Some("; + show(value.value(), os); + os << ")"; + } else { + os << "None"; + } +} + +} // namespace detail + } // namespace rc #endif // TILEDB_MISC_TDB_RAPIDCHECK_H From 4d8b66b3ec6c50e081a583fe15b2ff6a24c29976 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 21 Jan 2025 15:55:03 -0500 Subject: [PATCH 176/228] Fix tuple.h copyright --- test/support/stdx/tuple.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/support/stdx/tuple.h b/test/support/stdx/tuple.h index 4c781597abf..e79c2ce0c7a 100644 --- a/test/support/stdx/tuple.h +++ b/test/support/stdx/tuple.h @@ -5,7 +5,7 @@ * * The MIT License * - * @copyright Copyright (c) 2024 TileDB, Inc. + * @copyright Copyright (c) 2025 TileDB, 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 From a6c2ba1a3b21f8d378e6614ebca7d47f21a16f3b Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 21 Jan 2025 16:19:57 -0500 Subject: [PATCH 177/228] Fix Asserter --- test/src/unit-sparse-global-order-reader.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 4394b21b18a..c9ba6f80f93 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -1753,7 +1753,7 @@ TEST_CASE_METHOD( instance.fragments.push_back(fpoint); } - run(instance); + run(instance); }; SECTION("Example") { From 41a66e9886f14f54cde38fe0003ed7f919e7fcda Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 21 Jan 2025 16:20:18 -0500 Subject: [PATCH 178/228] Fix run_execute cell bound check --- test/src/unit-sparse-global-order-reader.cc | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index c9ba6f80f93..3d5382a79db 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2879,10 +2879,12 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { ASSERTER(dim_num_cells == att_num_cells); - if (dim_num_cells < instance.num_user_cells) { + const size_t num_cells_bound = + std::min(instance.num_user_cells, expect.size()); + if (dim_num_cells < num_cells_bound) { ASSERTER(status == TILEDB_COMPLETED); } else { - ASSERTER(dim_num_cells == instance.num_user_cells); + ASSERTER(dim_num_cells == num_cells_bound); } outcursor += dim_num_cells; From 3128865a2b04f5055815f12511435c60504bb2a2 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 21 Jan 2025 16:22:24 -0500 Subject: [PATCH 179/228] Add some Shrink sections for some rapidcheck examples --- test/src/unit-sparse-global-order-reader.cc | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 3d5382a79db..01f2724aea6 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -1303,7 +1303,7 @@ TEST_CASE_METHOD( doit.operator()(200, 8, 2); } - SECTION("Shrink") { + SECTION("Shrink", "Some examples found by rapidcheck") { doit.operator()( 2, 1, 1, {templates::Domain(1, 1)}); doit.operator()( @@ -1761,6 +1761,18 @@ TEST_CASE_METHOD( TILEDB_ROW_MAJOR, TILEDB_ROW_MAJOR, 4, 1024, 1, 4, false); } + SECTION("Shrink", "Some examples found by rapidcheck") { + doit.operator()( + TILEDB_ROW_MAJOR, + TILEDB_ROW_MAJOR, + 2, + 9, + 1, + 2, + false, + {std::make_pair(templates::Domain(2, 2), std::nullopt)}); + } + SECTION("Rapidcheck") { rc::prop("rapidcheck fragment skew", [doit]() { const auto tile_order = From 5c6c77a8424c653090c1223de05cf015bf6e920a Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 21 Jan 2025 16:41:50 -0500 Subject: [PATCH 180/228] Fix type_traits.h copyright --- tiledb/sm/misc/type_traits.h | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tiledb/sm/misc/type_traits.h b/tiledb/sm/misc/type_traits.h index bccbab90693..230c1358571 100644 --- a/tiledb/sm/misc/type_traits.h +++ b/tiledb/sm/misc/type_traits.h @@ -5,8 +5,7 @@ * * The MIT License * - * @copyright Copyright (c) 2017-2024 TileDB, Inc. - * @copyright Copyright (c) 2016 MIT and Intel Corporation + * @copyright Copyright (c) 2025 TileDB, 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 From 9c9a5f72f12e393d2c488440b256b7e4f6b711ef Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 21 Jan 2025 16:43:36 -0500 Subject: [PATCH 181/228] Update description in config/config.h --- tiledb/sm/config/config.h | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/tiledb/sm/config/config.h b/tiledb/sm/config/config.h index f4c757c33d4..204facf4249 100644 --- a/tiledb/sm/config/config.h +++ b/tiledb/sm/config/config.h @@ -233,7 +233,14 @@ class Config { /** Which reader to use for sparse global order queries. */ static const std::string SM_QUERY_SPARSE_GLOBAL_ORDER_READER; - /** If `true`, run preprocessing merge step in sparse global order reader */ + /** + * If nonzero, prior to loading the first tiles, the reader will run + * a preprocessing step to arrange tiles from all fragments in a single + * globally ordered list. This is expected to improve performance when + * there are many fragments or when the distribution in space of the + * tiles amongst the fragments is skewed. The value of the parameter + * specifies the amount of work per parallel task. + */ static const std::string SM_QUERY_SPARSE_GLOBAL_ORDER_PREPROCESS_TILE_MERGE; /** Which reader to use for sparse unordered with dups queries. */ From 3b42232f477b0c4b3f0d411d8422b1c708b6c89c Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 21 Jan 2025 22:28:13 -0500 Subject: [PATCH 182/228] Fix macos std::min ambiguity --- test/src/unit-sparse-global-order-reader.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 01f2724aea6..bac6808c075 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2891,8 +2891,8 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { ASSERTER(dim_num_cells == att_num_cells); - const size_t num_cells_bound = - std::min(instance.num_user_cells, expect.size()); + const uint64_t num_cells_bound = + std::min(instance.num_user_cells, expect.size()); if (dim_num_cells < num_cells_bound) { ASSERTER(status == TILEDB_COMPLETED); } else { From af68d3029956bf2f15f0444041e305ffb5d82512 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 22 Jan 2025 09:31:51 -0500 Subject: [PATCH 183/228] Add schema compatibility check to tiledb_submit_a_b --- test/performance/tiledb_submit_a_b.cc | 65 +++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 1c007171ddb..94e869e7db3 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -87,6 +87,7 @@ #include #include #include +#include #include "tiledb/api/c_api/array/array_api_internal.h" #include "tiledb/api/c_api/context/context_api_internal.h" @@ -96,6 +97,7 @@ #include "tiledb/sm/array_schema/dimension.h" #include "tiledb/sm/misc/comparators.h" #include "tiledb/sm/stats/duration_instrument.h" +#include "tiledb/type/apply_with_type.h" #include "external/include/nlohmann/json.hpp" @@ -246,6 +248,68 @@ tiledb::common::Status assertGlobalOrder( return tiledb::common::Status_Ok(); } +template +struct require_type { + static void dimension(const tiledb::sm::Dimension& dim) { + const auto dt = dim.type(); + const bool is_same = tiledb::type::apply_with_type( + [](auto arg) { return std::is_same_v; }, dt); + if (!is_same) { + throw std::runtime_error( + "Incompatible template type for dimension '" + dim.name() + + "' of type " + datatype_str(dt)); + } + } + + static void attribute(const tiledb::sm::Attribute& att) { + const auto dt = att.type(); + const bool is_same = tiledb::type::apply_with_type( + [](auto arg) { return std::is_same_v; }, dt); + if (!is_same) { + throw std::runtime_error( + "Incompatible template type for attribute '" + att.name() + + "' of type " + datatype_str(dt)); + } + } +}; + +template +static void check_compatibility(tiledb_array_t* array) { + using DimensionTuple = decltype(std::declval().dimensions()); + using AttributeTuple = decltype(std::declval().attributes()); + + constexpr auto expect_num_dims = std::tuple_size_v; + constexpr auto max_num_atts = std::tuple_size_v; + + const auto& schema = array->array()->array_schema_latest(); + + if (schema.domain().dim_num() != expect_num_dims) { + throw std::runtime_error( + "Expected " + std::to_string(expect_num_dims) + " dimensions, found " + + std::to_string(schema.domain().dim_num())); + } + if (schema.attribute_num() < max_num_atts) { + throw std::runtime_error( + "Expected " + std::to_string(max_num_atts) + " attributes, found " + + std::to_string(schema.attribute_num())); + } + + unsigned d = 0; + std::apply( + [&](std::vector...) { + (require_type::dimension(*schema.domain().shared_dimension(d++)), + ...); + }, + stdx::decay_tuple()); + + unsigned a = 0; + std::apply( + [&](std::vector...) { + (require_type::attribute(*schema.attribute(a++)), ...); + }, + stdx::decay_tuple()); +} + template static void run( TimeKeeper& time_keeper, @@ -284,6 +348,7 @@ static void run( // Open array for reading. CApiArray array(ctx, array_uri, TILEDB_READ); + check_compatibility(array); auto dimension_name = [&](unsigned d) -> std::string { return std::string( From dbba69e70fe3e8e1b40be5f789fb8125af157edf Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 22 Jan 2025 13:36:47 -0500 Subject: [PATCH 184/228] tiledb_submit_a_b runs multiple queries --- test/performance/tiledb_submit_a_b.cc | 272 +++++++++++++++++--------- test/support/stdx/tuple.h | 7 + tiledb/sm/stats/duration_instrument.h | 6 +- 3 files changed, 188 insertions(+), 97 deletions(-) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 94e869e7db3..6064762bfce 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -62,23 +62,27 @@ * "sm.query.sparse_global_order.preprocess_tile_merge": 128 * } * }, - * "query": { - * "layout": "global_order", - * "subarray": [ - * { - * "%": 30 - * } - * ] - * } + * "queries": [ + * { + * "layout": "global_order", + * "subarray": [ + * { + * "%": 30 + * } + * ] + * } + * ] * } * ``` * * The paths "a.config" and "b.config" are sets of key-value pairs * which are used to configure the "A" and "B" queries respectively. * - * The "query.layout" path is required and sets the results order. + * Each item in "queries" specifies a query to run the comparison for. + * + * The "layout" field is required and sets the results order. * - * The "query.subarray" path is an optional list of range specifications on + * The "subarray" path is an optional list of range specifications on * each dimension. Currently the only supported specification is * an object with a field "%" which adds a subarray range whose * bounds cover the specified percent of the non-empty domain @@ -116,16 +120,33 @@ using json = nlohmann::json; * Records durations as reported by `tiledb::sm::stats::DurationInstrument`. */ struct TimeKeeper { - std::map> durations; + struct StatKey { + std::string uri_; + std::string qlabel_; + bool is_a_; + }; - tiledb::sm::stats::DurationInstrument start_timer( - const std::string& stat) { - return tiledb::sm::stats::DurationInstrument(*this, stat); + using Timer = tiledb::sm::stats::DurationInstrument; + + std::map< + std::string, + std:: + map, std::vector>>> + durations; + + Timer start_timer(const StatKey& stat) { + return tiledb::sm::stats::DurationInstrument( + *this, stat); } void report_duration( - const std::string& stat, const std::chrono::duration duration) { - durations[stat].push_back(duration.count()); + const StatKey& stat, const std::chrono::duration duration) { + auto& stats = durations[stat.uri_][stat.qlabel_]; + if (stat.is_a_) { + stats.first.push_back(duration.count()); + } else { + stats.second.push_back(duration.count()); + } } /** @@ -134,88 +155,140 @@ struct TimeKeeper { void dump_durations(const char* path) const { std::ofstream dump(path); - for (const auto& stat : durations) { - dump << stat.first << " = ["; + json arrays; - bool is_first = true; - for (const auto& duration : stat.second) { - if (!is_first) { - dump << ", "; - } else { - is_first = false; - } - dump << duration; + for (const auto& uri : durations) { + json array; + array["uri"] = uri.first; + + for (const auto& qlabel : uri.second) { + const auto& a_durations = qlabel.second.first; + const auto& b_durations = qlabel.second.second; + const double a_sum = + std::accumulate(a_durations.begin(), a_durations.end(), (double)0); + const double b_sum = + std::accumulate(b_durations.begin(), b_durations.end(), (double)0); + + json a; + a["first"] = a_durations[0]; + a["sum"] = a_sum; + + json b; + b["first"] = b_durations[0]; + b["sum"] = b_sum; + + json run; + run["query"] = qlabel.first; + run["a"] = a; + run["b"] = b; + + array["queries"].push_back(run); } - dump << "]" << std::endl << std::endl; + arrays.push_back(array); } + + dump << std::setw(4) << arrays << std::endl; } }; -/** - * Constructs the query using the configuration's common "query" options. - */ -capi_return_t construct_query( +capi_return_t shrink_domain( tiledb_ctx_t* ctx, tiledb_array_t* array, - tiledb_query_t* query, - const json& jq) { - const auto layout = jq["layout"].get(); - if (layout == "global_order") { - TRY(ctx, tiledb_query_set_layout(ctx, query, TILEDB_GLOBAL_ORDER)); - } else if (layout == "row_major") { - TRY(ctx, tiledb_query_set_layout(ctx, query, TILEDB_ROW_MAJOR)); - } else if (layout == "col_major") { - TRY(ctx, tiledb_query_set_layout(ctx, query, TILEDB_COL_MAJOR)); - } else if (layout == "unordered") { - throw std::runtime_error( - "TILEDB_UNORDERED is not implemented; the unstable results order means " - "we cannot compare the coordinates from interleaved submits. This can " - "be implemented by buffering all of the query results and then sorting " - "on the coordinates"); - } else { - throw std::runtime_error("Invalid 'layout' for query: " + layout); + unsigned dim, + tiledb_subarray_t* subarray, + int percent) { + // FIXME: make generic + int is_empty; + int64_t domain[2]; + RETURN_IF_ERR(tiledb_array_get_non_empty_domain_from_index( + ctx, array, dim, &domain[0], &is_empty)); + if (is_empty) { + return TILEDB_OK; } - if (jq.find("subarray") != jq.end()) { - tiledb_subarray_t* subarray; - RETURN_IF_ERR(tiledb_subarray_alloc(ctx, array, &subarray)); - - tiledb_array_schema_t* schema; - RETURN_IF_ERR(tiledb_array_get_schema(ctx, array, &schema)); - - tiledb_domain_t* domain; - RETURN_IF_ERR(tiledb_array_schema_get_domain(ctx, schema, &domain)); - - int d = 0; - const auto& jsub = jq["subarray"]; - for (const auto& jdim : jsub) { - if (jdim.find("%") != jdim.end()) { - const int percent = jdim["%"].get(); - - // FIXME: make generic - int is_empty; - int64_t domain[2]; - RETURN_IF_ERR(tiledb_array_get_non_empty_domain_from_index( - ctx, array, d, &domain[0], &is_empty)); - if (is_empty) { - continue; + const auto span = (domain[1] - domain[0] + 1); + domain[0] += ((span * (100 - percent)) / 100) / 2; + domain[1] -= ((span * (100 - percent)) / 100) / 2; + + return tiledb_subarray_add_range( + ctx, subarray, dim, &domain[0], &domain[1], 0); +} + +struct QueryConfig { + std::string label_; + tiledb_layout_t layout_; + std::vector> subarray_percent_; + + static QueryConfig from_json(const json& jq) { + QueryConfig q; + q.label_ = jq["label"].get(); + + const auto layout = jq["layout"].get(); + if (layout == "global_order") { + q.layout_ = TILEDB_GLOBAL_ORDER; + } else if (layout == "row_major") { + q.layout_ = TILEDB_ROW_MAJOR; + } else if (layout == "col_major") { + q.layout_ = TILEDB_COL_MAJOR; + } else if (layout == "unordered") { + throw std::runtime_error( + "TILEDB_UNORDERED is not implemented; the unstable results order " + "means " + "we cannot compare the coordinates from interleaved submits. This " + "can " + "be implemented by buffering all of the query results and then " + "sorting " + "on the coordinates"); + } else { + throw std::runtime_error("Invalid 'layout' for query: " + layout); + } + + if (jq.find("subarray") != jq.end()) { + const auto& jsub = jq["subarray"]; + for (const auto& jdim : jsub) { + if (jdim.find("%") != jdim.end()) { + const int percent = jdim["%"].get(); + q.subarray_percent_.push_back(percent); + } else { + q.subarray_percent_.push_back(std::nullopt); } + } + } + return q; + } - const auto span = (domain[1] - domain[0] + 1); - domain[0] += ((span * (100 - percent)) / 100) / 2; - domain[1] -= ((span * (100 - percent)) / 100) / 2; + /** + * Applies this configuration to a query. + */ + capi_return_t apply( + tiledb_ctx_t* ctx, tiledb_array_t* array, tiledb_query_t* query) const { + TRY(ctx, tiledb_query_set_layout(ctx, query, layout_)); + + if (!subarray_percent_.empty()) { + tiledb_subarray_t* subarray; + RETURN_IF_ERR(tiledb_subarray_alloc(ctx, array, &subarray)); + + tiledb_array_schema_t* schema; + RETURN_IF_ERR(tiledb_array_get_schema(ctx, array, &schema)); - RETURN_IF_ERR(tiledb_subarray_add_range( - ctx, subarray, d, &domain[0], &domain[1], 0)); + tiledb_domain_t* domain; + RETURN_IF_ERR(tiledb_array_schema_get_domain(ctx, schema, &domain)); + + for (unsigned d = 0; d < subarray_percent_.size(); d++) { + if (subarray_percent_[d].has_value()) { + TRY(ctx, + shrink_domain( + ctx, array, d, subarray, subarray_percent_[d].value())); + } } + + TRY(ctx, tiledb_query_set_subarray_t(ctx, query, subarray)); } - tiledb_query_set_subarray_t(ctx, query, subarray); + return TILEDB_OK; } - - return TILEDB_OK; -} +}; template tiledb::common::Status assertGlobalOrder( @@ -314,7 +387,7 @@ template static void run( TimeKeeper& time_keeper, const char* array_uri, - const json& query_config, + const QueryConfig& query_config, tiledb_config_t* a_config, tiledb_config_t* b_config) { tiledb::test::SparseGlobalOrderReaderMemoryBudget memory; @@ -362,13 +435,24 @@ static void run( tiledb_query_t* a_query; TRY(ctx, tiledb_query_alloc(ctx, array, TILEDB_READ, &a_query)); TRY(ctx, tiledb_query_set_config(ctx, a_query, a_config)); - construct_query(ctx, array, a_query, query_config); + TRY(ctx, query_config.apply(ctx, array, a_query)); // Create query which DOES do merge tiledb_query_t* b_query; TRY(ctx, tiledb_query_alloc(ctx, array, TILEDB_READ, &b_query)); TRY(ctx, tiledb_query_set_config(ctx, b_query, b_config)); - construct_query(ctx, array, b_query, query_config); + TRY(ctx, query_config.apply(ctx, array, b_query)); + + const TimeKeeper::StatKey a_key = { + .uri_ = std::string(array_uri), + .qlabel_ = query_config.label_, + .is_a_ = true, + }; + const TimeKeeper::StatKey b_key = { + .uri_ = std::string(array_uri), + .qlabel_ = query_config.label_, + .is_a_ = false, + }; // helper to do basic checks on both auto do_submit = [&](auto& key, auto& query, auto& outdata) @@ -386,8 +470,7 @@ static void run( ctx, query, attribute_sizes, outdata.attributes(), attribute_name); { - tiledb::sm::stats::DurationInstrument qtimer = - time_keeper.start_timer(key); + TimeKeeper::Timer qtimer = time_keeper.start_timer(key); TRY(ctx, tiledb_query_submit(ctx, query)); } @@ -409,9 +492,6 @@ static void run( return std::make_pair(status, dim_num_cells); }; - const std::string a_key = std::string(array_uri) + ".a"; - const std::string b_key = std::string(array_uri) + ".b"; - while (true) { tiledb_query_status_t a_status, b_status; uint64_t a_num_cells, b_num_cells; @@ -509,12 +589,16 @@ int main(int argc, char** argv) { std::span array_uris( static_cast(&argv[2]), argc - 2); - for (const auto& array_uri : array_uris) { - try { - run(time_keeper, array_uri, config["query"], a_conf, b_conf); - } catch (const std::exception& e) { - std::cerr << "Error on array \"" << array_uri << "\": " << e.what() - << std::endl; + for (const auto& query : config["queries"]) { + QueryConfig qq = QueryConfig::from_json(query); + + for (const auto& array_uri : array_uris) { + try { + run(time_keeper, array_uri, qq, a_conf, b_conf); + } catch (const std::exception& e) { + std::cerr << "Error on array \"" << array_uri << "\": " << e.what() + << std::endl; + } } } diff --git a/test/support/stdx/tuple.h b/test/support/stdx/tuple.h index e79c2ce0c7a..953c041b258 100644 --- a/test/support/stdx/tuple.h +++ b/test/support/stdx/tuple.h @@ -35,6 +35,13 @@ namespace stdx { +template +constexpr auto decay_types(std::tuple const&) + -> std::tuple...>; + +template +using decay_tuple = decltype(decay_types(std::declval())); + /** * @return the transposition of row-oriented tuples into column-oriented tuples */ diff --git a/tiledb/sm/stats/duration_instrument.h b/tiledb/sm/stats/duration_instrument.h index 82ca74d6ac4..5158a7073b0 100644 --- a/tiledb/sm/stats/duration_instrument.h +++ b/tiledb/sm/stats/duration_instrument.h @@ -46,7 +46,7 @@ class Stats; /** * This class contains a simple duration instrument. */ -template +template class DurationInstrument { public: /* ****************************** */ @@ -54,7 +54,7 @@ class DurationInstrument { /* ****************************** */ /** Constructs a duration instrument object. */ - DurationInstrument(ParentType& parent_stats, const std::string stat_name) + DurationInstrument(ParentType& parent_stats, const StatNameType stat_name) : parent_stats_(parent_stats) , stat_name_(stat_name) , start_time_(std::chrono::high_resolution_clock::now()) { @@ -75,7 +75,7 @@ class DurationInstrument { ParentType& parent_stats_; /** Stat to report duration for. */ - const std::string stat_name_; + const StatNameType stat_name_; /** Start time of the duration instrument. */ std::chrono::high_resolution_clock::time_point start_time_; From 4f6cf87ae6e2c43184be1e43f597ee64c150f684 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 22 Jan 2025 15:55:10 -0500 Subject: [PATCH 185/228] Fix non-FIFO queue in parallel merge --- tiledb/common/algorithm/parallel_merge.cc | 6 +- tiledb/common/algorithm/parallel_merge.h | 17 +- .../algorithm/test/unit_parallel_merge.cc | 724 +++++++++++++++++- .../thread_pool/producer_consumer_queue.h | 2 +- 4 files changed, 740 insertions(+), 9 deletions(-) diff --git a/tiledb/common/algorithm/parallel_merge.cc b/tiledb/common/algorithm/parallel_merge.cc index 61a25d7dd55..54d2e1d321b 100644 --- a/tiledb/common/algorithm/parallel_merge.cc +++ b/tiledb/common/algorithm/parallel_merge.cc @@ -99,7 +99,11 @@ std::optional ParallelMergeFuture::await() { auto maybe_task = merge_tasks_.pop(); if (maybe_task.has_value()) { const auto m = merge_cursor_++; - throw_if_not_ok(maybe_task->wait()); + + // we must have FIFO + assert(m == maybe_task->p_); + + throw_if_not_ok(maybe_task->task_.wait()); return merge_bounds_[m].output_end(); } else { return std::nullopt; diff --git a/tiledb/common/algorithm/parallel_merge.h b/tiledb/common/algorithm/parallel_merge.h index 867bc420fc4..3009a59b9ab 100644 --- a/tiledb/common/algorithm/parallel_merge.h +++ b/tiledb/common/algorithm/parallel_merge.h @@ -202,9 +202,15 @@ struct ParallelMergeFuture { private: ParallelMergeMemoryResources memory_; + struct MergeUnitTask { + uint64_t p_; + tiledb::common::ThreadPool::Task task_; + }; + tdb::pmr::vector merge_bounds_; - tiledb::common::ProducerConsumerQueue - merge_tasks_; + tiledb::common:: + ProducerConsumerQueue> + merge_tasks_; // index of the next expected item in `merge_bounds_` uint64_t merge_cursor_; @@ -576,14 +582,17 @@ class ParallelMerge { future->merge_bounds_[p] = accumulated_stream_bounds; auto unit_future = pool->execute( tournament_merge, streams, cmp, future->merge_bounds_[p], output); - future->merge_tasks_.push(std::move(unit_future)); + + future->merge_tasks_.push(ParallelMergeFuture::MergeUnitTask{ + .p_ = p, .task_ = std::move(unit_future)}); } else { future->merge_bounds_[p].starts = future->merge_bounds_[p - 1].ends; future->merge_bounds_[p].ends = accumulated_stream_bounds.ends; auto unit_future = pool->execute( tournament_merge, streams, cmp, future->merge_bounds_[p], output); - future->merge_tasks_.push(std::move(unit_future)); + future->merge_tasks_.push(ParallelMergeFuture::MergeUnitTask{ + .p_ = p, .task_ = std::move(unit_future)}); } if (p < parallel_factor - 1) { diff --git a/tiledb/common/algorithm/test/unit_parallel_merge.cc b/tiledb/common/algorithm/test/unit_parallel_merge.cc index 3bff3093ae7..24411fc72be 100644 --- a/tiledb/common/algorithm/test/unit_parallel_merge.cc +++ b/tiledb/common/algorithm/test/unit_parallel_merge.cc @@ -593,9 +593,727 @@ TEST_CASE( TEST_CASE( "parallel merge rapidcheck uint64_t VerifyParallelMerge", "[algorithm][parallel_merge]") { - rc::prop("verify_parallel_merge", [](VerifyParallelMerge input) { - input.verify(); - }); + SECTION("Shrink", "Instances found previously") { + VerifyParallelMerge instance; + + instance.pool_concurrency = 16; + instance.options.parallel_factor = 9; + instance.options.min_merge_items = 838; + + instance.streams.push_back({0, 1964708352853888873}); + instance.streams.push_back( + {340504051726841736, + 344852335005584131, + 691432333882738270, + 905545882978089750, + 963620181783757219, + 2280318111133887983, + 2360815377599083728, + 2690651619726011594, + 2702620732101879003, + 3914614302172357712, + 3920420695891434736, + 3977654368208177782, + 4146162831399918660, + 4505912157534417120, + 8178660334482019917}); + instance.streams.push_back( + {250243497698869483, 342520146670513946, 460639582018147099, + 846477702552957623, 878044668058705049, 1357775358844315809, + 1370649669225041685, 1622322930626715479, 2422936557820787022, + 2664728687050573609, 4086304083561519276, 4604089473340659230, + 4695253583520271148, 4815681767159335799, 5076904023605818640, + 5161056711708826442, 5186830854753185896, 5320898922395769611, + 5702839098081247517, 6822853618435881949, 6906251812414549285, + 7306870941006900029, 7598257804853437932, 8000178328658993696, + 8447950993548860398, 8603384033055905231, 9090603704217711025}); + instance.streams.push_back( + {365034819649908200, 537278200643201754, 628028489233162476, + 1056053721546457072, 1631089707251576705, 2157012731714267023, + 2173302468290621506, 2190114075257687709, 3536586244893021144, + 4098871024727029043, 4219940064230999996, 5598434201692323521, + 5733035996731085551, 6151143939934632694, 6492184551178156461, + 6722564512870941217, 6828171325375387848, 6850196870345667255, + 6906839647346621570, 7360142404381869265, 7806912150418303184, + 8205639776231111202, 8313443253139136789, 8374628726628789598, + 8523234285186696347, 8807175409409426574, 8980081069707960942}); + instance.streams.push_back( + {4756539517425999047, + 4798031049377651616, + 5977213149434464454, + 6005322683776308758, + 6224906161411016770}); + instance.streams.push_back( + {111560816646238841, 163505226104379596, 242548861111792893, + 324636646688740289, 331129684786145021, 450004049859509952, + 550145571669736402, 654817179640157417, 671213505367837278, + 706726065752612744, 999609168490346640, 1100961644439277701, + 1414872839773979159, 1480413849222835949, 1738904315782367161, + 2027102963545979713, 2050103317583867222, 2107545739634791825, + 2141915563107849007, 2397505339096866433, 2576574260658871131, + 2845069992345569991, 3638249576331329231, 4441729953183251969, + 4452501912875377316, 4723777203540135155, 4766912539124929330, + 4819717683949706938, 4829678320063540316, 5088008666876198638, + 5107137635514295670, 5226988857720318312, 5382090861412964157, + 5433266385705824660, 5436982627608092533, 5517492712986358013, + 5747809558130145132, 6176513921995629268, 6211511678766187527, + 6275198405564436990, 6506598163638930866, 6507880583921708819, + 6623175656306519005, 6630776298659461624, 6700610119070243161, + 6873876316847742320, 6980573326640936743, 7252188579248074502, + 7326588526750597920, 7732810562794454604, 8063314292280663775, + 8099787036675479852, 8210799376119817540, 8349334719321385082, + 8494590863039018141, 8688281034194548590}); + instance.streams.push_back( + {320254704479545700, 420655069887453760, 429060508926581977, + 460196499028024337, 953561779682446307, 1039074518241554955, + 1188212173726072620, 1249146672866809218, 1704032370646125413, + 1737139332407886824, 1842382122035045074, 1844020417020201978, + 2207529352739723407, 2228893670053514494, 2923067297152209597, + 3144322480149264161, 3500619286656977840, 3533301382068690249, + 3964300661998913793, 4283662014244198584, 4446399025796556476, + 4536325536394672331, 4626130514711806540, 4682353918542575176, + 5676795806028379698, 5866113662510159298, 5879769286594349065, + 6276319267672760976, 6609827901507963179, 6646639152544114166, + 6859661685633003582, 6925850022106562901, 6985856750423128642, + 7158392145585477116, 7210529973088861882, 7412129063702359716, + 8016834345512203897, 8088581722283968874, 8296428221780161990, + 8731882166226556027, 9015400517265605074, 9138799535618320177, + 9155087561764082181}); + instance.streams.push_back( + {51454735997831121, 117143172861056921, 157721973952731687, + 881932815709816266, 927958564919087108, 976777298133626077, + 1032588504959403168, 1091640153918895492, 2054775938455049603, + 2113295226998029101, 2334647935409448680, 2484803221265381168, + 2523622069586548513, 2568249104269020600, 2593969581548133852, + 2739976198173245229, 3251441493648931270, 3305261233013288899, + 3544069342123672695, 3862199197989559994, 4217932160089300610, + 4415142305312094124, 4603038276368455611, 5042299410124212582, + 5076219980086298771, 6539019728857392915, 6945670032672847129, + 7327131529652747193, 7518215687926471612, 7593723469225582738, + 7602455822485877224, 7687988919468341787, 7744840933722738994, + 7902192185997485984, 8447693537973016685, 8912337266114505543, + 8986535159330870946, 9080616779175741434, 9148761422118920839, + 9176500996858521366}); + instance.streams.push_back( + {137326360377084220, + 149180667847225337, + 316502800165470534, + 1869340588901188621, + 2164437463958863510, + 2231858092884084971, + 2291182276971213098, + 2416425506771763220, + 3384721358062562721, + 3867990211623809440, + 3902778783808334295, + 4816387939906796007, + 5589009429684157617, + 5834067346218124068, + 6763754842773870515, + 8115638931351625710, + 8687742730714094669, + 8795917704285277995, + 8803839723448146545}); + + instance.streams.push_back( + {23678161213040705, 510241764617141901, 536672264796840765, + 817271100240475214, 824992929621593785, 936259153877883971, + 960608553447658296, 1016644615123228297, 1079513929429818370, + 1247622598380225718, 1265875085621850877, 1286630358723915721, + 1585784388405292846, 1882514364265324397, 1962983099044038040, + 2047240307888766369, 2089641636142471494, 2104081503879861800, + 2157499291986582082, 2242462293059025198, 2397818829671002449, + 2474643594359212111, 2626879015906626636, 2800942538936715183, + 2950124780977040035, 2962729703188401848, 3195363707418545400, + 3254400008948970680, 3341934193963561380, 3568105357608078905, + 3607416972776535502, 3742895572352962311, 3750922277236933324, + 3862781470922951700, 4133639907119172438, 4167991245860412544, + 4215009550182849694, 4348634397772330783, 4540720827918093668, + 4605892725108032743, 5112147611803069534, 5240743235082602958, + 5293780188735699423, 5344803738723997122, 5359644938166001876, + 5383045845773588147, 5460539756774575500, 5485135325974371263, + 5635140245844161553, 5710092722342554088, 5937538870686885810, + 6035986245880797533, 6332037239660591599, 6377740404404122118, + 6513905600152676553, 6745922411070403519, 6842657271710417778, + 7012233895223404545, 7082439372294707788, 7169430476557444103, + 7252294858470375727, 7296001643492304039, 7362899468051412298, + 7429857992136000225, 7554448534418702302, 7584251785448506899, + 7962776980238621413, 8113407862216908129, 8190116647855294077, + 8243475005557144977, 8246578745154143591, 8300197884230884027, + 8511569804890566846, 8521339560457020348, 8524049315697237765, + 8609444196105514408, 8705353794789460453, 8804664057451386903, + 8995133238524296428, 9002674372116479015}); + instance.streams.push_back( + {852799182518779523, 976211879747489697, 1037751937156943550, + 1183309793253415613, 1278268616507222314, 1451165745236086062, + 1621512904012972626, 1651735659866361412, 1777214878523913043, + 2214931377439983634, 2283177876896964407, 2738593353743079856, + 2820127664090891864, 2844373930338721165, 3189296936039027077, + 3254954514620592062, 3494386171639606090, 3551531641784773313, + 3684669015657700411, 3778424844868346851, 3807518953727490121, + 4014024793634145913, 4376528050311066505, 4709788895635016301, + 4802875159745211525, 4912077114664418965, 5154896847848578782, + 5399889012382577346, 5428207563089827676, 5490404187634371736, + 5658622587346343974, 5749250937460737403, 5854686605696362016, + 5982049066807674509, 6242946560536538596, 6541217505859643210, + 6573036243604757175, 6705697932294170025, 6713109902807273426, + 6921284692183694826, 6957992858094231231, 6967608779543192373, + 7154467612072689977, 7165366467803280993, 7528984442376590632, + 7562549652554641450, 7717229551377374413, 7754567712155703384, + 7868914565741615787, 7937187999987813578, 8701842928973852450, + 8892464805414749943, 9115325089189555539}); + instance.streams.push_back( + {20943666391368365, 50301707991823441, 78148549653558169, + 223537727943675077, 457374694131826701, 677769231307288719, + 738690972072549792, 808779816463584996, 1177985475557649325, + 1237824973985190974, 1409756236817959093, 1435911996961227602, + 1503641274947220311, 1511764275313859679, 1528131221941858934, + 1534381681586604241, 1542839573900239322, 1544003133799503333, + 1588804139273928590, 1801974190474587685, 1823514731001628521, + 2310083928250447665, 2326244911525083082, 2472708620182869557, + 2503087945401652204, 2600086538901526228, 2628865213158208270, + 2667076894330604699, 2707422557831791237, 2777846399740576177, + 2926005513144882263, 3140746181082342021, 3234383478068003737, + 3284748605682722794, 3654468547581799774, 3950170168303459161, + 3951670650353826130, 4047945913306191959, 4113807635664092203, + 4266045397888357498, 4299374661736063607, 4438427720679448353, + 4723519166837053894, 4771139015133323752, 4869515068761357173, + 4970536998559858982, 5073557385565822888, 5198166880328273127, + 5271572181663246052, 5314082606635789328, 5477307833345145180, + 5524207557087096653, 5886015987106668609, 6026454889985748648, + 6084803043157522481, 6158372282711088755, 6168222106544477004, + 6204006830525076915, 6408019547372630191, 6513075043672880140, + 6674516535180876795, 6822681571021993635, 6862399161419494149, + 7067115452221214899, 7138516978426804873, 7689152016280202686, + 7909580144088976322, 8324672428675972990, 8445663724062838862, + 8623264473608867537, 8670488819051193171, 8790796972651896445, + 8974117459504560162, 9096662290612606577}); + instance.streams.push_back( + {63166126530205759, 242392958169270718, 299572426752384365, + 371210267059975449, 409803653906946475, 468886860378125805, + 470084126843809657, 481593649516078721, 903834583636702311, + 958411081937070554, 1643594388685317464, 1867077484313968133, + 1878992910711600903, 2096269166292483012, 2221603162432482372, + 2367859021422440563, 2640404573406261967, 2677835376674463112, + 2762566780438590041, 2970834855784194277, 3245590543761084988, + 3331926875433018809, 3354894536277567765, 3359505071381462687, + 3402470977684680351, 3551747279395294877, 3643287767386033028, + 3785191949950430905, 4110028576828673249, 4170786080207290662, + 4219806117295035085, 4455232860654935884, 4536653577501826109, + 4545527876600156094, 4625757865323486607, 5113820071837780591, + 5431359545392859663, 5644169066530322315, 5812510450528493936, + 5887112635987962293, 5930820878774918392, 6034785964355711944, + 6046455894880780916, 6359379134180690054, 6427488655203662660, + 6488922940107192870, 6630859187399752714, 6647199501483481209, + 6702497299919482097, 6913283435188544583, 7000765135102730735, + 7323710144182268219, 7609074946912556631, 7630879955827434637, + 8012837334883764116, 8177369519382860768, 8373691128186397719, + 8586863860394192504, 8658966137662110078, 8745623093981340006, + 8759582612872391189, 9216498227193543282}); + instance.streams.push_back( + {83371540939874687, 99090153966040961, 265066980165143733, + 270185734230162060, 270764349377328729, 288791090302716150, + 515685752694836926, 527086694921111292, 537609362202016533, + 599732720196005842, 612031408334258699, 896904216546241482, + 999769207989122942, 1133043511208190641, 1693690049598026418, + 1772719663166431987, 1951519083505548569, 2091446513470438219, + 2893471902139543033, 2901452159654803955, 2911580424380098401, + 3011003540331906665, 3117245771853887492, 3340914718518675556, + 3454665172494129776, 3540466628941670785, 3631479891179203900, + 3820561738171968624, 3936713133309989730, 3974381306592113118, + 4072672321187480082, 4134085955791964608, 4252036902039087422, + 4648478980133725331, 4846311851024512063, 4922935334112814400, + 5143553175086741003, 5160210906682153305, 5190619362343208008, + 5286806527989322631, 5347835397983529763, 5480058516342719799, + 5509729406506462759, 6127143000822511824, 6247595783004300435, + 6538518445609528857, 6896728072888269877, 7042490559673111571, + 7797198894572665496, 7929344577293117573, 7953224965042879744, + 7972399940972724227, 7986080139156520841, 8024168897009383804, + 8496115956499380773, 8534953934598353778, 8562337432838158120, + 8630779688559053755, 8738379673480272412, 8936361841694130292, + 8961445256133042831, 9050699752745546434, 9092917754555593883, + 9141148046934586086, 9201142433737462276}); + instance.streams.push_back( + {978079929146482953, + 1409525660235222906, + 1509503421641846840, + 1731861974956539197, + 2287095917157287151, + 2385684395183412530, + 2877469094727427554, + 2877927961277983997, + 3309349110943104743, + 4453367091600589556, + 5445630170469231733, + 5578150355180782693, + 5965388825909305963, + 7337522975923020524, + 7397754781949302590, + 7445025070938323285, + 8373329521362769317, + 8912516122168670635}); + instance.streams.push_back( + {115099052366245073, 348810044115197638, 454297756558378945, + 525963111296184808, 593512962558545249, 798491669620362826, + 869327439478613518, 981097126473349404, 1002101216421266929, + 1034813295165320003, 1264393434589177395, 1345021521632827357, + 1350700929957070172, 1580333759835292921, 2012016518513982623, + 2391834124653836594, 2498010035820125293, 2899557215378165650, + 3159601364147854417, 3340910529178310262, 3383200101416954525, + 3595715391364568339, 3626747055096018491, 3745851203974667752, + 3815940356287831934, 3852280379023155391, 4075227241719476687, + 4277592629799541448, 4689266042484411530, 4808153135201443937, + 4906570846257116542, 5179952845682833086, 5182478464701929134, + 5292145640151081163, 5437316131059031693, 5541408742880580812, + 5682887433002060720, 5714191344223292326, 5731579309052433765, + 5865851265832527092, 6188296807941703853, 6308053424554918208, + 6453124965166334493, 6521001068166938079, 6648365436846851505, + 6686617273303982256, 6710657999109138778, 6742339195490840062, + 6821214221249683902, 6842753050238529660, 6944981180425698867, + 7040942354944121390, 7406993941394416541, 7495074592260989740, + 7527885580667786327, 8021058472116249049, 8303714322765813099, + 8368006548853101370, 8520467236911439331, 8655923628540909373, + 8730767083443288498, 8777309848157974118, 8803674745857201165, + 9120894070780185000, 9125782479443805331}); + instance.streams.push_back( + {82214946185582147, 638230386769953760, 930974016942623358, + 1225826573214176199, 1381192865341561544, 1909694923570278723, + 2780702356789299978, 3765543648183879203, 4018997926153994916, + 4089453881191544673, 4414382114507979262, 4662817260219833523, + 5168913145368538531, 5507337850840720077, 5747627772310775789, + 5991145201999384747, 6480288725892269305, 6807643059838787541, + 7597697085082207038, 7962815082597967978, 7969930733722087093, + 8001999050896731948, 8657206603771597168, 8750184224838691451, + 8761404347128873411, 9069817638306973173}); + instance.streams.push_back( + {487921498259078381, 679071658617431230, 764374888490611317, + 925238360244807201, 1157497519003408600, 1188010947874881034, + 1294245316709222942, 1308759129017077937, 1456021713368322450, + 1562145014347624567, 1665773474303121608, 1830853550932232765, + 1984890043982131546, 2027238322486055348, 2028467493513280808, + 2048654823136184085, 2050731743184357900, 2051006077165771338, + 2122605183153034700, 2164916519025182090, 2306688405259976416, + 2569911000316990930, 2707215687757190194, 2798872767746140499, + 3039005933784495926, 3155860803036790280, 3287334551636549192, + 3460037407701804509, 3480514362615843109, 3529761578628417370, + 3605421548746285977, 3668137967771604963, 3854196067176047399, + 4174953448500066916, 4183641199393801913, 4257822442447196266, + 4517889586519195136, 4545792098053641234, 4713067602976952130, + 4974919041423989357, 5200537300214769139, 5346144590813326687, + 5348593616115520032, 5450244594874073013, 5534173425947140314, + 5691231366916640932, 5854564983197580789, 6033804493935938541, + 6050661574631158637, 6338616026487638908, 6468369487438837308, + 6718920907523993661, 7494540413174816428, 7700271121561213222, + 7747996660032220767, 8153855686220060373, 8301835542127523736, + 8310814362457213780, 8357421137243286428, 8421758511454956292, + 8488672609098859079, 8601102709344884123, 8717181881737517673, + 8863705693387701392, 8949916871602876731}); + instance.streams.push_back( + {629323900936271853, + 1137842357866871600, + 2544291276218199502, + 2548577492105538193, + 4478450303133459836, + 5759012633820715055, + 5841580894289216512, + 6595012440364481517, + 7748533340176401956, + 7823400066738152787, + 7836255795681407155, + 8164837487421063835, + 8331526455846075045, + 8720314151969493218, + 8922460715960042588, + 8984160442812207787}); + instance.streams.push_back( + {285705971133895684, 1137948778300781933, 1456321730948168173, + 1701005447601122263, 1779219982736449125, 1901064185213667642, + 2323311467631549246, 3062745247368715424, 3255723597016881970, + 3620694899140096178, 3669875189360761436, 3820970890922102074, + 4421532518240930469, 4668525690843200017, 5059454289865985611, + 5138688983424923464, 5251311098633968937, 5272795211633015455, + 5429117732141768878, 5594384885252184809, 5736762777112863449, + 6375704680289738215, 6464379414503375352, 6595935814828333306, + 6883681170390130206, 6939426714908848607, 7195435632323483879, + 7393834961036793238, 7486339410612782998, 7822901423881124560, + 8205963132292198176, 8461200943179660674, 8784667488105527035, + 8795332699575539093, 9062848554475650570}); + instance.streams.push_back( + {649342514129014019, 1013609001391672817, 1552770829407841903, + 1706074387936052883, 2548683352257880495, 2780139330698936149, + 2951212375452138462, 3870386150608349786, 3960748984116259407, + 4515559401023148294, 4826228728631893094, 4828509659393215759, + 4836725078690018234, 5656385505541132678, 6107120255981371338, + 6586396852017701806, 6916523393735689456, 6917559196143595205, + 7077742276716875042, 7177046026795199725, 7339158529155971675, + 7856953593588045735}); + instance.streams.push_back( + {103312494178528482, 234405838252514844, 330032410803652666, + 360939175401072749, 519867640403597499, 593307860016959663, + 623778226224542360, 640643113234747207, 861311118685843861, + 1214613703731224172, 1529705270541373318, 2793264392155230386, + 3103915778589791456, 3146440560008244613, 3257465928619382554, + 3282715791883507152, 3323036804885755637, 4222176784995031174, + 4289430572947015273, 4321162610100759218, 4589140594212039846, + 4645145067993788922, 4816731277388022047, 4837005048398405969, + 5090487625726538849, 5298654518040793720, 5629080880414982651, + 6271444793144846681, 6524487041982597712, 7152771782154854398, + 7479111365116323952, 7669307042553249175, 7835952280336708833, + 8012716915770825646, 8016767728769763250, 8647290126259516347, + 8908070696861763158}); + instance.streams.push_back( + {468137721914325517, 505117020292705358, 617453048083099567, + 722432666278755340, 743944767710608524, 817337702921561702, + 964298007710047270, 1085788254735572558, 1229163532786185187, + 1267904705291553727, 1335338329848030023, 1456849486329528319, + 1458456523464408631, 1522873537225983581, 1690285984647312583, + 2279670235761762162, 2338619718483254870, 2393649659784264625, + 2494691992724655834, 2562853983115884052, 2631662446792181160, + 2671788079680194427, 2750913865345085626, 2777943866185224959, + 2819109626164132074, 2878115195039336529, 2927533075635477881, + 3074465162329395288, 3207616553987777400, 3436178864499235290, + 3687937503069163511, 3790031988860279331, 3808430880928299164, + 3972622864508455896, 3987422619560181033, 4304895466987371555, + 4591838038828380747, 4603042037887037413, 4770973830065599712, + 4830870656411977203, 5064320335183742324, 5068835356504398856, + 5247762342994044306, 5388649844889336005, 5430693440992736553, + 5857226827051826792, 5947841653468176431, 5971499925210093244, + 6474956286328840336, 6479747409942328448, 6594678433421674820, + 6648975724640599917, 6743815068136504683, 7164603377895064448, + 7176624776583216008, 7193972700885868440, 7267424656938049115, + 7755322816414385148, 7761365782584823534, 8208479161312198501, + 8231630458641300420, 8331053690100244654, 8534276101518867142, + 8542420471227393797, 8579650596911953516}); + instance.streams.push_back( + {92056098981300951, 183191604288414135, 425609311770953489, + 733399501951125206, 815017252624361671, 1174214440473219376, + 1527447727224758418, 1604558772613236346, 1815102969572261701, + 2020023237241195659, 2133221346465028689, 2309573638621438843, + 3059647754764119277, 3089018963508080823, 3520610057292262122, + 3706959419050779691, 4088044684824043707, 4266682710981069621, + 4367141727169343278, 4405220041098668848, 4572714270240917773, + 4582869992764212527, 4730057491341003468, 4863235522401558598, + 4960168984954372159, 5213732910162448626, 5265577214356543708, + 5579206437592754639, 5886198738755368709, 6057211466533567402, + 6272910612650927157, 6817377680671947413, 6819793996159518888, + 6835624039613756154, 7130584319880415797, 7563998286582581021, + 8048710272435454281, 8106671345277378212, 8200067328726125681, + 8397152345872926563, 8416609622231974393, 8432816603155051087, + 8546110210248055888, 8559128773431956735, 9040583859392571998, + 9079747481631520099, 9154620002255343025}); + instance.streams.push_back( + {186460269856899145, 312877223343858913, 392010051167932117, + 592734175915682324, 638573601945881452, 674255518590737590, + 688880322638418820, 1013857353576768172, 1112411780679572365, + 1139883811869746750, 1190575836840241598, 1207982001775715382, + 1211552828881387578, 1233350427106076327, 1385471799097662144, + 1531490738187958505, 1935384258720069435, 2071863720326007106, + 2289216337643919462, 2408743966916292164, 2454481366897894733, + 2814363792059893654, 2826202475368046979, 2833923842432602204, + 2975442383331736876, 3208835367202654229, 3292645341676952881, + 3305481577550342988, 3584241433084694833, 3743273293915887787, + 3879826256137027085, 4495397115498651467, 4589766514545949658, + 4645502849012582421, 4698623771475978677, 4921845594641293690, + 4973700052797881949, 5054012183269618598, 5121747673560119933, + 5155381082608426532, 5169820373996821774, 5193501081967012768, + 5300401153239731147, 5312160546165835590, 5366563483338550359, + 5407723435082400908, 5479116058910514884, 5852869581120320600, + 6056660948569423595, 6059285926721535698, 6066133154606264656, + 6150528155680608358, 6205405588570672356, 6455658007269102337, + 6517690050619506041, 6604837358100922800, 6740391577115078550, + 6754870494384726974, 6782744164019537637, 6858670266450659431, + 7031477863821497751, 7090103973012968883, 7125261418080735528, + 7333138589807036720, 7350755014925499557, 7353877654437638031, + 7400869418000115287, 7543529844050914728, 7603067751752487016, + 7799970764974260643, 7827063332152321532, 7975289673723089483, + 8090629125471632636, 8251074770046802788, 8328759754833931749, + 8685070722362163095, 8866312412480244316, 8866825913959048686, + 8917266639179383883, 8951106491369592720, 9006103287160623971, + 9081097821549706483, 9139726052133853214, 9156509614091645994, + 9211010153690967898}); + instance.streams.push_back( + {104230526944818390, 194872867561694437, 212441359160354232, + 321012325665976628, 431120611506335132, 533888981277404640, + 993196096130371670, 1030830090146476659, 1092324484284608889, + 1385143609848204220, 1447957761663850140, 1883972771473232369, + 1886132719335527511, 2041392723108802553, 2593917574312472347, + 2937372744931372239, 2996487507555474375, 3670702336583709390, + 3878940726871043993, 4157152156857244222, 4960850397334813825, + 5113920412938398589, 5169812923568587478, 5285613458152029336, + 5559283782542258439, 6157831502356165880, 6566627599020312553, + 7006145820121144150, 7225573382617770716, 7287615231139773891, + 7303873576606859546, 7317271246953513712, 7349671905717534681, + 7421533849456513697, 7526668599944036583, 7599086076101535523, + 7623492095781433338, 7711283192366365947, 7949095350580553873, + 8228783759112069242, 8295567568192555838, 8534365345714775019, + 8758541163334201549, 8821924156918821279, 8883120207037353129}); + instance.streams.push_back( + {58386620028953901, 603149038174852283, 784733004041771519, + 849256375728271061, 876434749911498209, 1153277607489026889, + 1284332405460994971, 1544280345202798527, 1569222782641349918, + 1605199731050122714, 1749308567067587821, 1863672956468109621, + 1926342313223625877, 2017927708422559327, 2027659154571342628, + 2117877383956303269, 2147965921916703578, 2233730766407072802, + 2286207197542499020, 2475529216448935277, 2537071554667498648, + 2561933176400165365, 2582706607166598310, 2629988231088809001, + 2668258253087373077, 2740522624473634895, 2750386422056636885, + 2772828149547986246, 2867225468300520004, 2895603989194672142, + 2916624250131739096, 3001758350138792451, 3023960594088693992, + 3103897686160767364, 3241265739486382608, 3272279529480798961, + 3519715009004256471, 3579844164298648535, 3659500891570190670, + 3829842546426485320, 3960671906396409644, 4140246018246094004, + 4420865993105853873, 4508843839749714898, 4523034759866345601, + 4957603909945162337, 5227269089039875466, 5336771787899565333, + 5345440780239373841, 5350973736703669852, 5510225308627802955, + 5695942359188224540, 5809619522614336735, 6728065708154526109, + 6829383044318697405, 6946524976100950664, 7153006052997047142, + 7167920757371519098, 7332662781768146263, 7373793185529622940, + 7447826569645645832, 7490493972617251142, 7831303308378876856, + 7843091442338072549, 7906935755119598122, 7914194807915183145, + 8039495272051275925, 8314689053957053388, 8387542429457488819, + 8466597753541104284, 8483741723290222858, 8599301570471318808, + 8716226300070556585, 8756763689271138139, 8955295406776997764, + 9012673292027226953, 9036242292240002258}); + instance.streams.push_back( + {221152499512725057, 468653913289994511, 573406392190002398, + 608549633585505280, 721590223379320754, 893804687502387698, + 994645852819618858, 1010504207871866436, 1226458553438834225, + 1322102128875218366, 1352617939551229058, 1367657169503026665, + 1431054573484265696, 1716664507247859085, 1819808470744051546, + 1832883987492520423, 1913575203897912572, 2078343662767049992, + 2144184772162852472, 2175338692854700871, 2515520083286899021, + 2658219409155723888, 2662216173057158227, 2791102212542615133, + 2810251461404023989, 3010160067457807675, 3198247003463721391, + 3207210396276830453, 3655687150569838438, 3742949808956029213, + 3939408096155747775, 3960751161684758408, 4062454131612436236, + 4126733056338249731, 4144406660403408900, 4160281903605117507, + 4160886814405501932, 4301845892945418166, 4335382680745413153, + 4505056660537898379, 4539434107911381923, 4559707416640177661, + 4581627552336714482, 4634932691215475440, 4652256940502250041, + 4709034174943716141, 4755067195445668372, 5031870437171497866, + 5086241845842489323, 5194885361498644327, 5335820239968792638, + 5381866204428555333, 5496620869292551625, 5607696027294180101, + 5641888110506579814, 5669980928511650063, 5692882051604805422, + 5869033276887872018, 5921828484003683005, 6018591452797071010, + 6043330380531903780, 6073539888671339222, 6349804831539426958, + 6466951481745709342, 6541925016453000741, 6606577194341690198, + 6655821998787366041, 6869403876421968685, 6952236217247677418, + 7064632969560758954, 7262799951330799140, 7299731795147493418, + 7452516877284055758, 7516278093926782953, 7724657529939371422, + 8277537304437407399, 8287042823318847978, 8375033050716909821, + 8383421555375425502, 8502394728509959035, 8502811416815954103, + 8601942285631187625, 8668259048921332853, 8679917789291195612, + 8902185247016931860, 8975374683294029673, 9018123807247419003, + 9081591481240593402, 9203064079702243357}); + instance.streams.push_back( + {9528858636270754, 74767308924267190, 92523084385092125, + 282510914521185986, 565939653640943279, 766893259352706773, + 1025334812935058435, 1086642043696211947, 1090103539577005545, + 1117559866996102610, 1150892608993861532, 1431520706401660610, + 1461925516829895752, 1491154270719434347, 1564570908804651001, + 1686708764851230308, 1693018175221748741, 1827964802829643811, + 1871856400612904987, 2269031422942301096, 2321184329693335268, + 2576411078823723038, 2901956572209495751, 3299554731045776001, + 3578582730292621865, 3605481165030718200, 3622286981235981834, + 4644544455473625042, 4704715844976049230, 4707408952461877611, + 5079828316722713851, 5332860656232543172, 5357945905588425444, + 5462910895481110403, 5486651617427880829, 5920963317972710651, + 5945547189608426266, 6097995450464204286, 6155072814328938262, + 6427618809519937314, 6498736386875881011, 6557345715154802672, + 6591361732789478133, 6795736613838753671, 7063310025635337958, + 7288379786078052405, 7477826447866021589, 7544407848018322037, + 7864854448541658478, 7924809231654480847, 8155610344096072120, + 8168318381948177277, 8489138127444983219, 8533218767481812480, + 8899267526102130921, 9051763646967677194}); + instance.streams.push_back( + {1160239440999495868, 1160627100977908024, 1445977391255418495, + 2100709699684953613, 2311002752371175131, 2326987246415777165, + 2409509260037050400, 2770408159376628543, 2885970397539782206, + 2897849329158521471, 3073323606059489201, 3097044942437084142, + 3169575954896219039, 3319951716499728030, 3494135475371065426, + 3496002297262349575, 3841375314084544552, 4007888085756092075, + 4717250350765676101, 4830685926850246039, 5066619425573186987, + 5142827563397788282, 5840091769545424048, 6185402624342137099, + 6520242562806050579, 7340354838898445609, 7446287944723287024, + 7819425906479635150, 8179247966270686645, 8793860582000764117, + 8876989220535143815, 8954309083312314973, 9189126043219875235}); + instance.streams.push_back( + {285145543975647006, 400464406369380005, 425052447908362043, + 558717929621862200, 780184890604101452, 802552417514008088, + 821353789735020113, 1461771191595340049, 1707838069528986431, + 1968758736472278720, 2179970727013701927, 2301096876229371288, + 2586755882369725036, 2642888823133285734, 2724932478710618595, + 2799219108908357183, 3210508660878406295, 3390360820647531457, + 3500608069640623603, 3794000156360803026, 3870372465245409129, + 3962864942943613290, 4052594741754433954, 4066439209995535105, + 4625364126734950672, 4755100478414716611, 4837056974522792783, + 5138435736439382420, 5252516194543331360, 5276885357297734928, + 5339285312869309795, 5383414072988834799, 5419750407305078642, + 5504475032307800929, 5531444670009604260, 5610198686052584931, + 5879342333105160359, 6227163917223061198, 6394549805539869304, + 6534105811771329013, 6538298296181075612, 6683665059254528394, + 6915570322469724208, 7215054837440533904, 7281318269792757267, + 7374371223175351465, 7562113046836517303, 7838864936942600980, + 7844181398943447729, 7942351656727780460, 7950201023600342051, + 8016629451324720863, 8044191201507598865, 8229239515369106446, + 8993425554747953330}); + instance.streams.push_back( + {125583000667520524, 214839438467369427, 249367830951934430, + 308261031714688831, 1134768329775635958, 1183613722982518046, + 1357058262944026234, 1357710861438500066, 1748413022866802117, + 1857598835930134266, 3055019199902384006, 3062281030982283629, + 3528678498241652912, 4063396096182487012, 4467122486929931357, + 4846856950656598934, 5785035888379523440, 5855646996685670595, + 6095919523788855289, 6205455101336312663, 6666077315644367652, + 6757656301020430328, 7275449995231256065, 7306530842416062343, + 7409626532873823691, 7534989846036976651, 7970400668449759273, + 8069921964831893849, 8196425277077193920, 8389499930778050745, + 8701072344837825080}); + instance.streams.push_back( + {33564926325826831, + 260291524539990308, + 374076536813175702, + 445706191910983060, + 2615929502664660778, + 2870926401217071659, + 3088279460307954084, + 4633051241451350592, + 4636848118939709473, + 4982408764483706312, + 6145844808415620138, + 6503848779295974662, + 6803286364456511128, + 7301808229090216723, + 7527961052034746578, + 8755659592883848787}); + instance.streams.push_back( + {50391867020209568, 109973211041671007, 426365914246397281, + 780216749836386995, 927137594156658301, 1280297890312031835, + 1356872469290895499, 1646520938759084189, 1770128407464172181, + 1876106980342957607, 1992958432625854788, 2093272732169720418, + 2241800693961349596, 2315318181472203645, 2726778221200855105, + 2731148968788143056, 2784451205304767311, 2889302029852103008, + 2914456568933696331, 3033308498900870284, 3069608453528247024, + 3147683791728929502, 3162396888809983919, 3173374637506992417, + 3306363691517815071, 3567685134602033707, 3732317047444193546, + 3864954392412328092, 4304660060986936816, 4666673387047506586, + 4765432491107097576, 5108976781632236584, 5110400105803816066, + 5200335758573175396, 5640989876800271598, 5665274647100247796, + 5702149274760003174, 5728664901759643253, 5788098188481174646, + 5795560782524298146, 5852686300889056461, 5973152740219653583, + 5977429576954595040, 6103223664281897127, 6111609016377058074, + 6235168972471541048, 6237552891612236200, 6335487740557681471, + 6353432702630052474, 6365163378435576774, 6779431742606687646, + 7055429296271398220, 7142092728874400757, 7160088139694496237, + 7161080095306591569, 7195482977425683059, 7265328107229114597, + 7323761413577848136, 7330533757178675459, 7346545798057982568, + 7543397985293350879, 7605471257315203444, 7677075232577432180, + 7770682335946669870, 7801171200783882642, 7879542219695847235, + 7889434293679595443, 8027893157968605900, 8131696298458998640, + 8221580404217896279, 8287527045961328812, 8340326440093299701, + 8355257415634238153, 8638160453384811767, 8654116231443860953, + 8713028169329039008, 8741251814621908606}); + instance.streams.push_back( + {38552260850125970, 306379511766359735, 711300096798339321, + 892018019103254274, 2364206832643103382, 2420535690560486819, + 2980386295304646523, 3101600218221266377, 3141790607746941505, + 3999134727658658069, 4462290689715673199, 5204914504379723995, + 5467769513963022713, 5963515685465164797, 6307703548487249061, + 6521727204313461172, 6746273471781072806, 7133296936471547422, + 7413405836526190068, 7460132468170665268, 9118746925568133696}); + instance.streams.push_back( + {311746355635346537, 357280282242159933, 453794801155624312, + 470124658103437043, 480500591405735777, 642968216130651766, + 677382766653156986, 742336241959437289, 995597266969363512, + 1438905128019740072, 1774939855749446509, 2534734553076187949, + 2675412948582352200, 2945299999579094336, 3085388497824334414, + 3244765152133405099, 3327833825330566369, 3703194822023351032, + 3765658082600741596, 3825281533385903512, 3883149142639520189, + 3938352829216712487, 4120683798246541427, 4407478830753418084, + 4714722467734011191, 4778090814542958798, 4865684247595699604, + 5564250447415400601, 5675380593702259207, 5953049262426054107, + 6322306904987766773, 6576158849963679983, 6585910776451113262, + 6695013865519715556, 6822580595787479730, 7005579721591160602, + 7053187268953133165, 7137337825055068764, 7154614606682799364, + 7162695738484944585, 7204207140983511889, 7657343589727357634, + 7726203520276412700, 7885282374693638275, 7898080252964135291, + 8063562120530344324, 8111621434828014272, 8136473663541304080, + 8955369150293893931, 8974612926096998142}); + instance.streams.push_back( + {197420451713811676, 281445277459917203, 740082088833530644, + 1290412288467608392, 1294985646752861418, 1459338324889185197, + 1545467342772798788, 1725296824044696622, 1790928042402142285, + 1819195369020482914, 1845318846420546596, 1916804860036750684, + 1934795655439316734, 2123406663108189928, 2161364767387674755, + 2199349719437568153, 2201446205661462318, 2304422276794393017, + 2367362048086896201, 2520840158493853225, 2637488475771115834, + 2695468587025769956, 2868497673804512236, 2986730852667904426, + 3049027770127401337, 3088814443181055397, 3142185799974885998, + 3145610541985422508, 3376917417266132278, 3474311476906199144, + 3480295733245426278, 3756461875941152626, 3768960023228980524, + 3786412095536719213, 3818558100696073513, 3832731138330958677, + 4013125545855280982, 4058451558097473690, 4061654997981645019, + 4079781890597804187, 4145540956726304260, 4213067535490157135, + 4387646299216426469, 4532586244009288120, 4599368551837569974, + 4719137179319807721, 4774240273842121853, 4823692999474104868, + 4878380451678305609, 5080805857519288366, 5272561874891052360, + 5393458881428272808, 5758340275080427297, 5886639535186242096, + 5912173887580571910, 6054663179080587357, 6138520848359196864, + 6388603114548809966, 6409577084921583203, 6536152899730873147, + 6594754796754003142, 6835272684932377793, 6860056536556710109, + 7219012018184660258, 7316465780676346496, 7661428841823577249, + 7906168207960936451, 8184686816308280852, 8916752945036324140, + 8985070033502476478, 9145582347483890099}); + instance.streams.push_back( + {153324836101059419, 158780138759790326, 174215935958616755, + 179731076471247779, 269276934678469319, 393639793694666172, + 432631673890631004, 670995085036662336, 721887896591779145, + 748122147291880857, 771326157253533848, 783650624759832650, + 1014975687794962171, 1379488317060232881, 1463947847163713623, + 1559978541312388344, 1677050512347768440, 1679788471700081953, + 1697344722681459414, 1796670363905560694, 1875437320199800047, + 1958046921272092141, 2012390301428218497, 2032697606825981501, + 2063860587455918843, 2076755491339447914, 2163553294232027512, + 2185286087988362175, 2223845822471630205, 2508102531103681824, + 2576117223285183167, 2714809954419134452, 2792838922831161963, + 2900435853024427713, 2937083093165162409, 2939480550795499937, + 3072243433185798666, 3228964562507837847, 3257430266232071473, + 3401500904443689432, 3410334239187579089, 3620509784201584781, + 3707729414802869989, 3750258169852724918, 3756680820327526039, + 3900685920024254630, 4024598042066710501, 4188274758129042402, + 4323638211698224578, 4580570891550236607, 5009980347824435138, + 5122166740162881305, 5329562660783230510, 5372442803515899785, + 5418173101818824583, 5485499651120889655, 5521202335275584192, + 5729929930779710255, 5831082418654309238, 5982740560563910312, + 5995159670704615124, 6088662697234208829, 6120996226448363060, + 6214200379979203888, 6468448109110284451, 6525029247710148615, + 6581357662703674942, 6780008824250326220, 6875650962481044987, + 6938461292439554984, 7027602581413514955, 7100073000167249186, + 7208005517459406600, 7228453795929202340, 7603315537325918661, + 7611050507858817021, 7644795789683514694, 7868219793368483911, + 7966758117976278992, 8011601341464333596, 8077164278247408893, + 8181466141626535480, 8771155570066914574, 8879865897468670264, + 8885481783436167324, 9025760847000160788, 9164430375972757624, + 9173963918183109716}); + instance.streams.push_back( + {1059433874806495660, 2105370760666799235, 2550457278644318367, + 2588733214791715635, 3081056091507702768, 3536661695747334932, + 3642559614667528631, 3844174653456592779, 3874828053345872276, + 4259604692437009810, 4395405895302928283, 4805831959048227379, + 5035667734207638846, 5089440685667631502, 5170000450239185361, + 5544572753180138321, 5748328650770747767, 6212120819500360922, + 6812019836498165705, 6962001610179228000, 7132285316145578530, + 7511954185336675079, 7912817484509858870, 8708158977779035254, + 8907676047014618471, 8913855313747888928}); + + instance.verify(); + } + + SECTION("Rapidcheck") { + rc::prop("verify_parallel_merge", [](VerifyParallelMerge input) { + input.verify(); + }); + } } TEST_CASE( diff --git a/tiledb/common/thread_pool/producer_consumer_queue.h b/tiledb/common/thread_pool/producer_consumer_queue.h index 522a5b24ca4..6afcaaee7be 100644 --- a/tiledb/common/thread_pool/producer_consumer_queue.h +++ b/tiledb/common/thread_pool/producer_consumer_queue.h @@ -151,7 +151,7 @@ class ProducerConsumerQueue { Item item = std::move(queue_.front()); if constexpr (std::is_same>::value) { - queue_.pop(item); + queue_.pop(); } else if constexpr (std::is_same>::value) { queue_.pop_front(); } else { From 279e94a41e375b6338f1fa502d53fcd6949b3971 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 22 Jan 2025 21:30:08 -0500 Subject: [PATCH 186/228] Block waiting for parallel merge when complete, for simplicity --- tiledb/sm/query/readers/sparse_global_order_reader.cc | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 77a9230673c..70588f8748a 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -360,6 +360,13 @@ Status SparseGlobalOrderReader::dowork() { } } + if (preprocess_future.has_value() && !incomplete()) { + // clean up gracefully and let the merge finish, freeing input etc + // (this also helps simplify assertions about memory usage) + preprocess_future->block(); + preprocess_future.reset(); + } + // End the iteration. end_iteration(result_tiles); } while (!user_buffers_full && incomplete()); From e9581fbfaa7c42dbeaa358a14c16b16517aebc18 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 22 Jan 2025 22:36:43 -0500 Subject: [PATCH 187/228] Out-of-order MBRs test disable fragment metadata check for REST --- test/src/unit-sparse-global-order-reader.cc | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index bac6808c075..dec8875f84a 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -1594,7 +1594,11 @@ TEST_CASE_METHOD( sm::GlobalCellCmp globalcmp( array->array()->array_schema_latest().domain()); - if (std::is_same::value) { + // check that we actually have out-of-order MBRs + // (disable on REST where we have no metadata) + // (disable with rapidcheck where this may not be guaranteed) + if (!vfs_test_setup_.is_rest() && + std::is_same::value) { bool any_out_of_order = false; for (size_t f = 0; !any_out_of_order && f < fragment_metadata.size(); f++) { From 78dd2fd65bedc66f22bf628eb8bd32f10c710080 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 23 Jan 2025 20:21:06 -0500 Subject: [PATCH 188/228] Stats::get_counter --- tiledb/sm/stats/stats.cc | 11 +++++++++++ tiledb/sm/stats/stats.h | 2 ++ 2 files changed, 13 insertions(+) diff --git a/tiledb/sm/stats/stats.cc b/tiledb/sm/stats/stats.cc index 4f85b0f6924..493c82156f3 100644 --- a/tiledb/sm/stats/stats.cc +++ b/tiledb/sm/stats/stats.cc @@ -189,6 +189,17 @@ void Stats::add_counter(const std::string& stat, uint64_t count) { } } +uint64_t Stats::get_counter(const std::string& stat) const { + const std::string new_stat = prefix_ + stat; + std::unique_lock lck(mtx_); + auto maybe = counters_.find(new_stat); + if (maybe == counters_.end()) { + return 0; + } else { + return maybe->second; + } +} + DurationInstrument Stats::start_timer(const std::string& stat) { return DurationInstrument(*this, stat); } diff --git a/tiledb/sm/stats/stats.h b/tiledb/sm/stats/stats.h index 5cea25f2d37..754edcfe2c3 100644 --- a/tiledb/sm/stats/stats.h +++ b/tiledb/sm/stats/stats.h @@ -163,6 +163,8 @@ class Stats { /** Adds `count` to the input counter stat. */ void add_counter(const std::string& stat, uint64_t count); + uint64_t get_counter(const std::string& stat) const; + /** Returns true if statistics are currently enabled. */ bool enabled() const; From 86c90c108003ee68a546e7bb75eafd7d64605759 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 23 Jan 2025 20:21:56 -0500 Subject: [PATCH 189/228] Fix incorrrect incomplete() return for preprocess having more tiles --- tiledb/sm/query/readers/sparse_global_order_reader.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 70588f8748a..cdff46fd903 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -197,7 +197,7 @@ bool SparseGlobalOrderReader::incomplete() const { } else if (!preprocess_tile_order_.enabled_) { return memory_used_for_coords_total_ != 0; } else if (preprocess_tile_order_.has_more_tiles()) { - return false; + return true; } else { [[maybe_unused]] const size_t mem_for_tile_order = sizeof(ResultTileId) * preprocess_tile_order_.tiles_.size(); From bb475b7f07aabb104218c9a9a87bb5126eb30984 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 24 Jan 2025 10:46:09 -0500 Subject: [PATCH 190/228] Always wait for merge before accessing tiles_ --- .../readers/sparse_global_order_reader.cc | 84 ++++++++++++------- .../readers/sparse_global_order_reader.h | 6 +- 2 files changed, 58 insertions(+), 32 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index cdff46fd903..297a0b4d311 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -96,6 +96,9 @@ struct PreprocessTileMergeFuture { /** the merge future */ std::optional> merge_; + /** the known bound in the output up to which the merge has completed */ + std::optional safe_bound_; + private: void free_input() { for (auto& fragment : fragment_result_tiles_) { @@ -123,18 +126,36 @@ struct PreprocessTileMergeFuture { * * @return true if the requested cursor is available, false otherwise */ - bool wait_for(uint64_t cursor) { + bool wait_for(uint64_t request_cursor) { if (!merge_.has_value()) { return true; } - std::optional bound = merge_.value()->valid_output_bound(); - if (bound.has_value() && bound.value() >= cursor) { + if (safe_bound_.has_value() && request_cursor < safe_bound_.value()) { return true; } - while ((bound = merge_.value()->await()).has_value()) { - if (bound.value() >= cursor) { + const auto prev_safe_bound_ = safe_bound_; + + safe_bound_ = merge_.value()->valid_output_bound(); + if (safe_bound_.has_value() && safe_bound_.value() > request_cursor) { + if (prev_safe_bound_.has_value() && + prev_safe_bound_.value() > safe_bound_.value()) { + throw SparseGlobalOrderReaderInternalError( + "Unexpected preprocess tile merge state: out of order merge " + "bound"); + } + return true; + } + + while ((safe_bound_ = merge_.value()->await()).has_value()) { + if (prev_safe_bound_.has_value() && + prev_safe_bound_.value() > safe_bound_.value()) { + throw SparseGlobalOrderReaderInternalError( + "Unexpected preprocess tile merge state: out of order merge " + "bound"); + } + if (safe_bound_.value() > request_cursor) { return true; } } @@ -334,12 +355,12 @@ Status SparseGlobalOrderReader::dowork() { if (array_schema_.cell_order() == Layout::HILBERT) { auto&& [user_buffs_full, rcs] = merge_result_cell_slabs( - max_num_cells_to_copy(), result_tiles); + max_num_cells_to_copy(), result_tiles, preprocess_future); user_buffers_full = user_buffs_full; result_cell_slabs = std::move(rcs); } else { auto&& [user_buffs_full, rcs] = merge_result_cell_slabs( - max_num_cells_to_copy(), result_tiles); + max_num_cells_to_copy(), result_tiles, preprocess_future); user_buffers_full = user_buffs_full; result_cell_slabs = std::move(rcs); } @@ -820,7 +841,7 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( default: stdx::unreachable(); } -} // namespace tiledb::sm +} template std::vector @@ -1014,7 +1035,7 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( if (merge_future.has_value()) { const bool wait_ok = - merge_future->wait_for(preprocess_tile_order_.cursor_); + merge_future->wait_for(preprocess_tile_order_.cursor_ - 1); if (!wait_ok) { throw SparseGlobalOrderReaderInternalError( "Waiting for preprocess tile merge results failed"); @@ -1063,28 +1084,16 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( } if (preprocess_tile_order_.has_more_tiles()) { - size_t rt = preprocess_tile_order_.cursor_; - size_t rt_merge_bound = - (merge_future.has_value() ? rt : preprocess_tile_order_.tiles_.size()); - while (rt < preprocess_tile_order_.tiles_.size()) { - if (rt == rt_merge_bound) { - auto merge_await = merge_future->await(); - if (merge_await.has_value()) { - rt_merge_bound = merge_await.value(); - } else if ((merge_await = - merge_future->merge_.value()->valid_output_bound()) - .has_value()) { - rt_merge_bound = merge_await.value(); - } else { + uint64_t rt; + for (rt = preprocess_tile_order_.cursor_; + rt < preprocess_tile_order_.tiles_.size(); + rt++) { + if (merge_future.has_value()) { + if (!merge_future->wait_for(rt)) { throw SparseGlobalOrderReaderInternalError( "Unexpected preprocess tile merge state: expected new merge " "bound but found none"); } - if (merge_await.value() <= rt) { - throw SparseGlobalOrderReaderInternalError( - "Unexpected preprocess tile merge state: out of order merge " - "bound"); - } } const auto f = preprocess_tile_order_.tiles_[rt].fragment_idx_; @@ -1113,7 +1122,6 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( if (merge_future.has_value()) { merge_future->block(); merge_future.reset(); - rt_merge_bound = preprocess_tile_order_.tiles_.size(); continue; } @@ -1134,8 +1142,6 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( break; } } - - rt++; } // update position for next iteration @@ -1149,6 +1155,13 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( for (uint64_t ri = preprocess_tile_order_.cursor_; all_tiles_loaded && ri < preprocess_tile_order_.tiles_.size(); ri++) { + if (merge_future.has_value()) { + if (!merge_future->wait_for(ri)) { + throw SparseGlobalOrderReaderInternalError( + "Waiting for preprocess tile merge results failed"); + } + } + const auto& tile = preprocess_tile_order_.tiles_[ri]; if (tile.fragment_idx_ == f) { all_tiles_loaded = false; @@ -1583,7 +1596,9 @@ template template tuple> SparseGlobalOrderReader::merge_result_cell_slabs( - uint64_t num_cells, std::vector& result_tiles) { + uint64_t num_cells, + std::vector& result_tiles, + std::optional& merge_future) { auto timer_se = stats_->start_timer("merge_result_cell_slabs"); // User gave us some empty buffers, exit. @@ -1636,6 +1651,13 @@ SparseGlobalOrderReader::merge_result_cell_slabs( for (uint64_t rt = preprocess_tile_order_.cursor_; rt < preprocess_tile_order_.tiles_.size(); rt++) { + if (merge_future.has_value()) { + if (!merge_future->wait_for(rt)) { + throw SparseGlobalOrderReaderInternalError( + "Unexpected preprocess tile merge state: expected new merge " + "bound but found none"); + } + } const auto frt = preprocess_tile_order_.tiles_[rt].fragment_idx_; if (has_pending_tiles(frt)) { merge_bound.emplace(RangeLowerBound{ diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index 69d4390c95a..87d37416edd 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -427,12 +427,16 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, * * @param num_cells Number of cells that can be copied in the user buffer. * @param result_tiles Result tiles per fragment. + * @param merge_future handle to polling the preprocess merge stream + * (if it has not completed yet). * * @return user_buffers_full, result_cell_slabs. */ template tuple> merge_result_cell_slabs( - uint64_t num_cells, std::vector& result_tiles); + uint64_t num_cells, + std::vector& result_tiles, + std::optional& merge_future); /** * Compute parallelization parameters for a tile copy operation. From 978ee1238618e356afd2c9c535a1990dcab246f5 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 24 Jan 2025 10:46:30 -0500 Subject: [PATCH 191/228] assertGlobalOrder returns a little more info --- test/performance/tiledb_submit_a_b.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 6064762bfce..6c7667d0c1f 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -314,7 +314,8 @@ tiledb::common::Status assertGlobalOrder( if (globalcmp(nexttuple, prevtuple)) { return tiledb::common::Status_Error( - "Out of order: pos=" + std::to_string(i) + + "Out of order: start= " + std::to_string(start) + + ", pos=" + std::to_string(i) + ", end=" + std::to_string(end) + ", num_cells=" + std::to_string(num_cells)); } } From efb6799c90f1a53f02fc8f45164cfef76e6642b9 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 24 Jan 2025 10:46:57 -0500 Subject: [PATCH 192/228] tiledb_submit_a_b return if there is an error --- test/performance/tiledb_submit_a_b.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 6c7667d0c1f..db5df068b9c 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -599,6 +599,8 @@ int main(int argc, char** argv) { } catch (const std::exception& e) { std::cerr << "Error on array \"" << array_uri << "\": " << e.what() << std::endl; + + return 1; } } } From eb8ad29a0055010b121d0e46424c412c72baacae Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 24 Jan 2025 11:47:20 -0500 Subject: [PATCH 193/228] tiledb_submit_a_b record loop_num, internal_loop_num --- test/performance/tiledb_submit_a_b.cc | 91 ++++++++++++++++++++------- tiledb/sm/stats/stats.cc | 18 +++++- tiledb/sm/stats/stats.h | 7 ++- 3 files changed, 91 insertions(+), 25 deletions(-) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index db5df068b9c..206556b7de5 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -39,7 +39,7 @@ * same results and recording the time spent calling `tiledb_query_submit`. * * After executing upon all of the arrays, the timing information is - * dumped to `/tmp/time_keeper.out`. + * dumped to `/tmp/tiledb_submit_a_b.json`. * * The arrays must have the same schema, whose physical type is reflected * by the `using Fragment = ` declaration in the middle of @@ -116,36 +116,58 @@ using Asserter = AsserterRuntimeException; using json = nlohmann::json; +template +json optional_json(std::optional value) { + if (value.has_value()) { + return json(value.value()); + } else { + return json(); + } +} + /** * Records durations as reported by `tiledb::sm::stats::DurationInstrument`. */ -struct TimeKeeper { +struct StatKeeper { struct StatKey { std::string uri_; std::string qlabel_; bool is_a_; }; - using Timer = tiledb::sm::stats::DurationInstrument; + struct StatValue { + std::vector durations; + std::map metrics; + }; + + using Timer = tiledb::sm::stats::DurationInstrument; - std::map< - std::string, - std:: - map, std::vector>>> - durations; + /** records statistics of each submit call by "array.query" */ + std::map>> + statistics; Timer start_timer(const StatKey& stat) { - return tiledb::sm::stats::DurationInstrument( + return tiledb::sm::stats::DurationInstrument( *this, stat); } void report_duration( const StatKey& stat, const std::chrono::duration duration) { - auto& stats = durations[stat.uri_][stat.qlabel_]; + auto& stats = statistics[stat.uri_][stat.qlabel_]; + if (stat.is_a_) { + stats.first.durations.push_back(duration.count()); + } else { + stats.second.durations.push_back(duration.count()); + } + } + + void report_metric( + const StatKey& stat, const std::string& name, const json& value) { + auto& stats = statistics[stat.uri_][stat.qlabel_]; if (stat.is_a_) { - stats.first.push_back(duration.count()); + stats.first.metrics[name] = value; } else { - stats.second.push_back(duration.count()); + stats.second.metrics[name] = value; } } @@ -157,13 +179,13 @@ struct TimeKeeper { json arrays; - for (const auto& uri : durations) { + for (const auto& uri : statistics) { json array; array["uri"] = uri.first; for (const auto& qlabel : uri.second) { - const auto& a_durations = qlabel.second.first; - const auto& b_durations = qlabel.second.second; + const auto& a_durations = qlabel.second.first.durations; + const auto& b_durations = qlabel.second.second.durations; const double a_sum = std::accumulate(a_durations.begin(), a_durations.end(), (double)0); const double b_sum = @@ -172,10 +194,16 @@ struct TimeKeeper { json a; a["first"] = a_durations[0]; a["sum"] = a_sum; + for (const auto& metric : qlabel.second.first.metrics) { + a[metric.first] = metric.second; + } json b; b["first"] = b_durations[0]; b["sum"] = b_sum; + for (const auto& metric : qlabel.second.second.metrics) { + b[metric.first] = metric.second; + } json run; run["query"] = qlabel.first; @@ -386,7 +414,7 @@ static void check_compatibility(tiledb_array_t* array) { template static void run( - TimeKeeper& time_keeper, + StatKeeper& stat_keeper, const char* array_uri, const QueryConfig& query_config, tiledb_config_t* a_config, @@ -444,12 +472,12 @@ static void run( TRY(ctx, tiledb_query_set_config(ctx, b_query, b_config)); TRY(ctx, query_config.apply(ctx, array, b_query)); - const TimeKeeper::StatKey a_key = { + const StatKeeper::StatKey a_key = { .uri_ = std::string(array_uri), .qlabel_ = query_config.label_, .is_a_ = true, }; - const TimeKeeper::StatKey b_key = { + const StatKeeper::StatKey b_key = { .uri_ = std::string(array_uri), .qlabel_ = query_config.label_, .is_a_ = false, @@ -471,7 +499,7 @@ static void run( ctx, query, attribute_sizes, outdata.attributes(), attribute_name); { - TimeKeeper::Timer qtimer = time_keeper.start_timer(key); + StatKeeper::Timer qtimer = stat_keeper.start_timer(key); TRY(ctx, tiledb_query_submit(ctx, query)); } @@ -545,6 +573,25 @@ static void run( break; } } + + // record additional stats + const tiledb::sm::Query& a_query_internal = *a_query->query_; + const tiledb::sm::Query& b_query_internal = *b_query->query_; + const auto& a_stats = *a_query_internal.stats(); + const auto& b_stats = *b_query_internal.stats(); + + stat_keeper.report_metric( + a_key, "loop_num", optional_json(a_stats.find_counter("loop_num"))); + stat_keeper.report_metric( + b_key, "loop_num", optional_json(b_stats.find_counter("loop_num"))); + stat_keeper.report_metric( + a_key, + "internal_loop_num", + optional_json(a_stats.find_counter("internal_loop_num"))); + stat_keeper.report_metric( + b_key, + "internal_loop_num", + optional_json(b_stats.find_counter("internal_loop_num"))); } // change this to match the schema of the target arrays @@ -585,7 +632,7 @@ int main(int argc, char** argv) { RETURN_IF_ERR(json2config(&a_conf, config["a"])); RETURN_IF_ERR(json2config(&b_conf, config["b"])); - TimeKeeper time_keeper; + StatKeeper stat_keeper; std::span array_uris( static_cast(&argv[2]), argc - 2); @@ -595,7 +642,7 @@ int main(int argc, char** argv) { for (const auto& array_uri : array_uris) { try { - run(time_keeper, array_uri, qq, a_conf, b_conf); + run(stat_keeper, array_uri, qq, a_conf, b_conf); } catch (const std::exception& e) { std::cerr << "Error on array \"" << array_uri << "\": " << e.what() << std::endl; @@ -608,7 +655,7 @@ int main(int argc, char** argv) { tiledb_config_free(&b_conf); tiledb_config_free(&a_conf); - time_keeper.dump_durations("/tmp/time_keeper.out"); + stat_keeper.dump_durations("/tmp/tiledb_submit_a_b.json"); return 0; } diff --git a/tiledb/sm/stats/stats.cc b/tiledb/sm/stats/stats.cc index 493c82156f3..6c439866cbc 100644 --- a/tiledb/sm/stats/stats.cc +++ b/tiledb/sm/stats/stats.cc @@ -189,17 +189,31 @@ void Stats::add_counter(const std::string& stat, uint64_t count) { } } -uint64_t Stats::get_counter(const std::string& stat) const { +std::optional Stats::get_counter(const std::string& stat) const { const std::string new_stat = prefix_ + stat; std::unique_lock lck(mtx_); auto maybe = counters_.find(new_stat); if (maybe == counters_.end()) { - return 0; + return std::nullopt; } else { return maybe->second; } } +std::optional Stats::find_counter(const std::string& stat) const { + const auto mine = get_counter(stat); + if (mine.has_value()) { + return mine; + } + for (const auto& child : children_) { + const auto theirs = child.find_counter(stat); + if (theirs.has_value()) { + return theirs; + } + } + return std::nullopt; +} + DurationInstrument Stats::start_timer(const std::string& stat) { return DurationInstrument(*this, stat); } diff --git a/tiledb/sm/stats/stats.h b/tiledb/sm/stats/stats.h index 754edcfe2c3..f978c289f01 100644 --- a/tiledb/sm/stats/stats.h +++ b/tiledb/sm/stats/stats.h @@ -163,7 +163,12 @@ class Stats { /** Adds `count` to the input counter stat. */ void add_counter(const std::string& stat, uint64_t count); - uint64_t get_counter(const std::string& stat) const; + /** Returns the value of the counter for `stat`, if any */ + std::optional get_counter(const std::string& stat) const; + + /** Searches through the child stats to find a counter with the given name, + * and returns its value */ + std::optional find_counter(const std::string& stat) const; /** Returns true if statistics are currently enabled. */ bool enabled() const; From f17312cd2805a858c415c6b9ae6e94ef075f1bf5 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 24 Jan 2025 14:40:56 -0500 Subject: [PATCH 194/228] Fix wait_for await call --- tiledb/sm/query/readers/sparse_global_order_reader.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 297a0b4d311..578927086dd 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -148,7 +148,7 @@ struct PreprocessTileMergeFuture { return true; } - while ((safe_bound_ = merge_.value()->await()).has_value()) { + while ((safe_bound_ = await()).has_value()) { if (prev_safe_bound_.has_value() && prev_safe_bound_.value() > safe_bound_.value()) { throw SparseGlobalOrderReaderInternalError( From 524d408fce13a6ce3fb5dc51e9a6c7a83278a3ea Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 27 Jan 2025 16:05:25 -0500 Subject: [PATCH 195/228] REST re-compute tile order again, including position, instead of serializing anything --- .../readers/sparse_global_order_reader.cc | 50 ++- .../readers/sparse_global_order_reader.h | 52 ++- .../query/readers/sparse_index_reader_base.cc | 16 - .../query/readers/sparse_index_reader_base.h | 44 --- tiledb/sm/serialization/query.cc | 26 -- tiledb/sm/serialization/tiledb-rest.capnp | 12 - tiledb/sm/serialization/tiledb-rest.capnp.c++ | 142 ++------ tiledb/sm/serialization/tiledb-rest.capnp.h | 303 +----------------- 8 files changed, 111 insertions(+), 534 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 578927086dd..6a4c65ce03a 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -194,6 +194,10 @@ SparseGlobalOrderReader::SparseGlobalOrderReader( // Initialize memory budget variables. refresh_config(); + // Clear preprocess tile order + preprocess_tile_order_.enabled_ = false; + preprocess_tile_order_.cursor_ = 0; + const auto preprocess_tile_merge_min_items = config_.get( "sm.query.sparse_global_order.preprocess_tile_merge"); preprocess_tile_order_.enabled_ = @@ -243,17 +247,6 @@ void SparseGlobalOrderReader::refresh_config() { memory_budget_.refresh_config(config_, "sparse_global_order"); } -template -void SparseGlobalOrderReader::set_preprocess_tile_order_cursor( - uint64_t cursor, std::vector tiles) { - preprocess_tile_order_.enabled_ = true; - preprocess_tile_order_.cursor_ = cursor; - preprocess_tile_order_.tiles_ = tiles; - - memory_used_for_coords_total_ += - sizeof(ResultTileId) * preprocess_tile_order_.tiles_.size(); -} - template Status SparseGlobalOrderReader::dowork() { auto timer_se = stats_->start_timer("dowork"); @@ -294,6 +287,7 @@ Status SparseGlobalOrderReader::dowork() { // iterations are needed. preprocess_future.emplace(memory_used_for_coords_total_); preprocess_compute_result_tile_order(preprocess_future.value()); + preprocess_set_cursor_from_read_state(preprocess_future.value()); } else if (preprocess_tile_order_.enabled_) { // NB: we could have avoided loading these in the first place // since we already have determined which tiles qualify, and their order @@ -843,6 +837,40 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( } } +template +void SparseGlobalOrderReader::preprocess_set_cursor_from_read_state( + PreprocessTileMergeFuture& merge_future) { + const auto& state = read_state_.frag_idx(); + const auto& tiles = preprocess_tile_order_.tiles_; + // Find the lower bound cursor whose tile is greater than all of + // the read state tiles. See `create_result_tiles_using_preprocess`. + // If the cursor is nonzero then we will create result tiles + // between the read state and the cursor. + uint64_t bound = 0; + for (size_t f = 0; f < state.size(); f++) { + for (; bound < tiles.size(); bound++) { + if (state[f].tile_idx_ == 0 && state[f].cell_idx_ == 0) { + // initial state (even if tile 0 is filtered by the subarray) + break; + } + + merge_future.wait_for(bound); + + if (tiles[bound].fragment_idx_ != f) { + continue; + } else if (state[f].cell_idx_ == 0) { + if (state[f].tile_idx_ <= tiles[bound].tile_idx_) { + break; + } + } else if (state[f].tile_idx_ < tiles[bound].tile_idx_) { + break; + } + } + } + + preprocess_tile_order_.cursor_ = bound; +} + template std::vector SparseGlobalOrderReader::create_result_tiles( diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index 87d37416edd..8a1454f0f50 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -66,6 +66,20 @@ enum class AddNextCellResult { MergeBound }; +/** + * Identifies an order in which to load result tiles. + * See `preprocess_tile_order_`. + */ +struct PreprocessTileOrder { + bool enabled_; + size_t cursor_; + std::vector tiles_; + + bool has_more_tiles() const { + return enabled_ && cursor_ < tiles_.size(); + } +}; + /** Processes sparse global order read queries. */ template @@ -136,10 +150,6 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, /** Returns the name of the strategy */ std::string name() override; - /** Used in deserialization */ - virtual void set_preprocess_tile_order_cursor( - uint64_t cursor, std::vector tiles) override; - private: /* ********************************* */ /* PRIVATE ATTRIBUTES */ @@ -148,6 +158,18 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, /** UID of the logger instance */ inline static std::atomic logger_id_ = 0; + /** + * State for the optional mode to preprocess the tiles across + * all fragments and merge them into a single list which identifies + * the order they should be read in. + * + * This is used to merge the tiles + * into a single globally-ordered list prior to loading. + * Tile identifiers in this list are sorted using their starting ranges + * and have already had the subarray (if any) applied. + */ + PreprocessTileOrder preprocess_tile_order_; + /** * Result tiles currently for which we loaded coordinates but couldn't * process in the previous iteration. @@ -274,6 +296,28 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, void preprocess_compute_result_tile_order( PreprocessTileMergeFuture& merge_future); + /** + * Identifies the current position in the preprocess tile stream using + * the read state, and updates the cursor to that position. + * This is called after starting the result tile order. + * + * When running libtiledb natively, this is only called in the + * first instance of `tiledb_query_submit` and sets the cursor + * to that position. + * + * When running libtiledb against the REST server, this is called + * on the REST server for each `tiledb_query_submit`. + * We assume that recomputing the tile order for each message + * is cheaper than serializing the tile order after computing it once. + * However, as the read state progresses over the subarray, + * the tiles which qualify as input to the tile merge change. + * This causes the tile list to vary from submit to submit. + * Hence instead of serializing the position in the list we must + * recompute it. + */ + void preprocess_set_cursor_from_read_state( + PreprocessTileMergeFuture& merge_future); + /** * Create the result tiles. * diff --git a/tiledb/sm/query/readers/sparse_index_reader_base.cc b/tiledb/sm/query/readers/sparse_index_reader_base.cc index bec5d883bd2..1956529a140 100644 --- a/tiledb/sm/query/readers/sparse_index_reader_base.cc +++ b/tiledb/sm/query/readers/sparse_index_reader_base.cc @@ -83,10 +83,6 @@ SparseIndexReaderBase::SparseIndexReaderBase( "Cannot initialize reader; Buffers not set"); } - // Clear preprocess tile order - preprocess_tile_order_.enabled_ = false; - preprocess_tile_order_.cursor_ = 0; - // Check subarray check_subarray(); @@ -137,18 +133,6 @@ void SparseIndexReaderBase::set_read_state(ReadState read_state) { read_state_ = std::move(read_state); } -const PreprocessTileOrder& SparseIndexReaderBase::preprocess_tile_order() - const { - return preprocess_tile_order_; -} - -void SparseIndexReaderBase::set_preprocess_tile_order_cursor( - uint64_t, std::vector) { - throw SparseIndexReaderBaseException( - "Internal error: set_preprocess_tile_order_cursor for unsupported sparse " - "index reader"); -} - uint64_t SparseIndexReaderBase::available_memory() { return memory_budget_.total_budget() - memory_used_for_coords_total_ - tmp_read_state_.memory_used_tile_ranges() - diff --git a/tiledb/sm/query/readers/sparse_index_reader_base.h b/tiledb/sm/query/readers/sparse_index_reader_base.h index 834cab67838..2a7553a70ed 100644 --- a/tiledb/sm/query/readers/sparse_index_reader_base.h +++ b/tiledb/sm/query/readers/sparse_index_reader_base.h @@ -294,20 +294,6 @@ struct ignored_tile_hash { } }; -/** - * Identifies an order in which to load result tiles. - * See `SparseIndexReader::preprocess_tile_order_`. - */ -struct PreprocessTileOrder { - bool enabled_; - size_t cursor_; - std::vector tiles_; - - bool has_more_tiles() const { - return enabled_ && cursor_ < tiles_.size(); - } -}; - /** * Processes sparse read queries by keeping progress in fragments as indexes. */ @@ -615,41 +601,11 @@ class SparseIndexReaderBase : public ReaderBase { */ void set_read_state(ReadState read_state); - /** - * Returns the preprocess tile order state. - * Used to assist the global order reader with deserialization. - * - * @return const reference to the preprocess tile order state - */ - const PreprocessTileOrder& preprocess_tile_order() const; - - /** - * Sets the preprocess tile order cursor. Used only for deserialization. - * - * @param cursor New cursor value. - */ - virtual void set_preprocess_tile_order_cursor( - uint64_t cursor, std::vector tiles); - protected: /* ********************************* */ /* PROTECTED ATTRIBUTES */ /* ********************************* */ - /** - * State for the optional mode to preprocess the tiles across - * all fragments and merge them into a single list which identifies - * the order they should be read in. - * - * This is used by SparseGlobalOrderReader to merge the tiles - * into a single globally-ordered list prior to loading. - * Tile identifiers in this list are sorted using their starting ranges - * and have already had the subarray (if any) applied. - * - * (this is declared here for serialization purposes) - */ - PreprocessTileOrder preprocess_tile_order_; - /** Read state. */ ReadState read_state_; diff --git a/tiledb/sm/serialization/query.cc b/tiledb/sm/serialization/query.cc index c7d992529f7..48e0b2df4dd 100644 --- a/tiledb/sm/serialization/query.cc +++ b/tiledb/sm/serialization/query.cc @@ -933,20 +933,6 @@ Status index_reader_to_capnp( auto stats_builder = reader_builder->initStats(); stats_to_capnp(stats, &stats_builder); - // Tile order - if (reader.preprocess_tile_order().enabled_) { - const auto& pstate = reader.preprocess_tile_order(); - - auto preprocess = reader_builder->initPreprocess(); - preprocess.setCursor(reader.preprocess_tile_order().cursor_); - - auto tiles = preprocess.initTiles(pstate.tiles_.size()); - for (size_t t = 0; t < pstate.tiles_.size(); t++) { - tiles[t].setFragIdx(pstate.tiles_[t].fragment_idx_); - tiles[t].setTileIdx(pstate.tiles_[t].tile_idx_); - } - } - return Status::Ok(); } @@ -1180,18 +1166,6 @@ Status index_reader_from_capnp( reader->set_stats(stats_data); } - if (reader_reader.hasPreprocess()) { - const auto& preproc = reader_reader.getPreprocess(); - std::vector tiles(preproc.getTiles().size()); - for (size_t t = 0; t < preproc.getTiles().size(); t++) { - tiles[t] = ResultTileId{ - .fragment_idx_ = preproc.getTiles()[t].getFragIdx(), - .tile_idx_ = preproc.getTiles()[t].getTileIdx(), - }; - } - reader->set_preprocess_tile_order_cursor(preproc.getCursor(), tiles); - } - return Status::Ok(); } diff --git a/tiledb/sm/serialization/tiledb-rest.capnp b/tiledb/sm/serialization/tiledb-rest.capnp index 2dcd17d5ba3..b8dfa283620 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp +++ b/tiledb/sm/serialization/tiledb-rest.capnp @@ -717,16 +717,6 @@ struct ReadStateIndex { # Is the reader done adding result tiles. } -struct PreprocessTileOrder { -# State of the sparse global order reader preprocess tile order. - - cursor @0 :UInt64; - # Position in the preprocess tile order list. - - tiles @1 :List(ResultTileId); - # List of tiles arranged in the order they must be opened -} - struct ReaderIndex { # Reader struct for indexed readers. @@ -744,8 +734,6 @@ struct ReaderIndex { stats @4 :Stats; # Stats object - - preprocess @5 :PreprocessTileOrder; } struct Query { diff --git a/tiledb/sm/serialization/tiledb-rest.capnp.c++ b/tiledb/sm/serialization/tiledb-rest.capnp.c++ index 858729ad1f5..6ddb73b29ca 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp.c++ +++ b/tiledb/sm/serialization/tiledb-rest.capnp.c++ @@ -5521,84 +5521,17 @@ const ::capnp::_::RawSchema s_c86c77b5f6a2bf0f = { 2, 3, i_c86c77b5f6a2bf0f, nullptr, nullptr, { &s_c86c77b5f6a2bf0f, nullptr, nullptr, 0, 0, nullptr }, false }; #endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<53> b_818a8600b3452aa4 = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 164, 42, 69, 179, 0, 134, 138, 129, - 18, 0, 0, 0, 1, 0, 1, 0, - 127, 216, 135, 181, 36, 146, 125, 181, - 1, 0, 7, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 21, 0, 0, 0, 50, 1, 0, 0, - 37, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 33, 0, 0, 0, 119, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 116, 105, 108, 101, 100, 98, 45, 114, - 101, 115, 116, 46, 99, 97, 112, 110, - 112, 58, 80, 114, 101, 112, 114, 111, - 99, 101, 115, 115, 84, 105, 108, 101, - 79, 114, 100, 101, 114, 0, 0, 0, - 0, 0, 0, 0, 1, 0, 1, 0, - 8, 0, 0, 0, 3, 0, 4, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 41, 0, 0, 0, 58, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 36, 0, 0, 0, 3, 0, 1, 0, - 48, 0, 0, 0, 2, 0, 1, 0, - 1, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1, 0, 1, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 45, 0, 0, 0, 50, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 40, 0, 0, 0, 3, 0, 1, 0, - 68, 0, 0, 0, 2, 0, 1, 0, - 99, 117, 114, 115, 111, 114, 0, 0, - 9, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 9, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 116, 105, 108, 101, 115, 0, 0, 0, - 14, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3, 0, 1, 0, - 16, 0, 0, 0, 0, 0, 0, 0, - 184, 237, 115, 78, 105, 239, 203, 175, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 14, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, } -}; -::capnp::word const* const bp_818a8600b3452aa4 = b_818a8600b3452aa4.words; -#if !CAPNP_LITE -static const ::capnp::_::RawSchema* const d_818a8600b3452aa4[] = { - &s_afcbef694e73edb8, -}; -static const uint16_t m_818a8600b3452aa4[] = {0, 1}; -static const uint16_t i_818a8600b3452aa4[] = {0, 1}; -const ::capnp::_::RawSchema s_818a8600b3452aa4 = { - 0x818a8600b3452aa4, b_818a8600b3452aa4.words, 53, d_818a8600b3452aa4, m_818a8600b3452aa4, - 1, 2, i_818a8600b3452aa4, nullptr, nullptr, { &s_818a8600b3452aa4, nullptr, nullptr, 0, 0, nullptr }, false -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<112> b_9b9a5fc7713a8692 = { +static const ::capnp::_::AlignedData<96> b_9b9a5fc7713a8692 = { { 0, 0, 0, 0, 5, 0, 6, 0, 146, 134, 58, 113, 199, 95, 154, 155, 18, 0, 0, 0, 1, 0, 0, 0, 127, 216, 135, 181, 36, 146, 125, 181, - 6, 0, 7, 0, 0, 0, 0, 0, + 5, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 0, 242, 0, 0, 0, 33, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 29, 0, 0, 0, 87, 1, 0, 0, + 29, 0, 0, 0, 31, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 116, 105, 108, 101, 100, 98, 45, 114, @@ -5606,49 +5539,42 @@ static const ::capnp::_::AlignedData<112> b_9b9a5fc7713a8692 = { 112, 58, 82, 101, 97, 100, 101, 114, 73, 110, 100, 101, 120, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, - 24, 0, 0, 0, 3, 0, 4, 0, + 20, 0, 0, 0, 3, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 153, 0, 0, 0, 58, 0, 0, 0, + 125, 0, 0, 0, 58, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 148, 0, 0, 0, 3, 0, 1, 0, - 160, 0, 0, 0, 2, 0, 1, 0, + 120, 0, 0, 0, 3, 0, 1, 0, + 132, 0, 0, 0, 2, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 157, 0, 0, 0, 74, 0, 0, 0, + 129, 0, 0, 0, 74, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 156, 0, 0, 0, 3, 0, 1, 0, - 168, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 3, 0, 1, 0, + 140, 0, 0, 0, 2, 0, 1, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 165, 0, 0, 0, 82, 0, 0, 0, + 137, 0, 0, 0, 82, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 164, 0, 0, 0, 3, 0, 1, 0, - 176, 0, 0, 0, 2, 0, 1, 0, + 136, 0, 0, 0, 3, 0, 1, 0, + 148, 0, 0, 0, 2, 0, 1, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 1, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 173, 0, 0, 0, 82, 0, 0, 0, + 145, 0, 0, 0, 82, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 172, 0, 0, 0, 3, 0, 1, 0, - 184, 0, 0, 0, 2, 0, 1, 0, + 144, 0, 0, 0, 3, 0, 1, 0, + 156, 0, 0, 0, 2, 0, 1, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 181, 0, 0, 0, 50, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 176, 0, 0, 0, 3, 0, 1, 0, - 188, 0, 0, 0, 2, 0, 1, 0, - 5, 0, 0, 0, 5, 0, 0, 0, - 0, 0, 1, 0, 5, 0, 0, 0, + 153, 0, 0, 0, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 185, 0, 0, 0, 90, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 184, 0, 0, 0, 3, 0, 1, 0, - 196, 0, 0, 0, 2, 0, 1, 0, + 148, 0, 0, 0, 3, 0, 1, 0, + 160, 0, 0, 0, 2, 0, 1, 0, 108, 97, 121, 111, 117, 116, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5689,15 +5615,6 @@ static const ::capnp::_::AlignedData<112> b_9b9a5fc7713a8692 = { 164, 161, 6, 21, 161, 54, 224, 199, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 16, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 112, 114, 101, 112, 114, 111, 99, 101, - 115, 115, 0, 0, 0, 0, 0, 0, - 16, 0, 0, 0, 0, 0, 0, 0, - 164, 42, 69, 179, 0, 134, 138, 129, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, } @@ -5705,17 +5622,16 @@ static const ::capnp::_::AlignedData<112> b_9b9a5fc7713a8692 = { ::capnp::word const* const bp_9b9a5fc7713a8692 = b_9b9a5fc7713a8692.words; #if !CAPNP_LITE static const ::capnp::_::RawSchema* const d_9b9a5fc7713a8692[] = { - &s_818a8600b3452aa4, &s_c7e036a11506a1a4, &s_c86c77b5f6a2bf0f, &s_dba20dec138adac9, &s_eaf57cb9871fc06f, }; -static const uint16_t m_9b9a5fc7713a8692[] = {3, 0, 5, 2, 4, 1}; -static const uint16_t i_9b9a5fc7713a8692[] = {0, 1, 2, 3, 4, 5}; +static const uint16_t m_9b9a5fc7713a8692[] = {3, 0, 2, 4, 1}; +static const uint16_t i_9b9a5fc7713a8692[] = {0, 1, 2, 3, 4}; const ::capnp::_::RawSchema s_9b9a5fc7713a8692 = { - 0x9b9a5fc7713a8692, b_9b9a5fc7713a8692.words, 112, d_9b9a5fc7713a8692, m_9b9a5fc7713a8692, - 5, 6, i_9b9a5fc7713a8692, nullptr, nullptr, { &s_9b9a5fc7713a8692, nullptr, nullptr, 0, 0, nullptr }, true + 0x9b9a5fc7713a8692, b_9b9a5fc7713a8692.words, 96, d_9b9a5fc7713a8692, m_9b9a5fc7713a8692, + 4, 5, i_9b9a5fc7713a8692, nullptr, nullptr, { &s_9b9a5fc7713a8692, nullptr, nullptr, 0, 0, nullptr }, true }; #endif // !CAPNP_LITE static const ::capnp::_::AlignedData<387> b_96ba49d0f8b23ccc = { @@ -11390,18 +11306,6 @@ constexpr ::capnp::_::RawSchema const* ReadStateIndex::_capnpPrivate::schema; #endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL #endif // !CAPNP_LITE -// PreprocessTileOrder -#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL -constexpr uint16_t PreprocessTileOrder::_capnpPrivate::dataWordSize; -constexpr uint16_t PreprocessTileOrder::_capnpPrivate::pointerCount; -#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL -#if !CAPNP_LITE -#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL -constexpr ::capnp::Kind PreprocessTileOrder::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* PreprocessTileOrder::_capnpPrivate::schema; -#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL -#endif // !CAPNP_LITE - // ReaderIndex #if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL constexpr uint16_t ReaderIndex::_capnpPrivate::dataWordSize; diff --git a/tiledb/sm/serialization/tiledb-rest.capnp.h b/tiledb/sm/serialization/tiledb-rest.capnp.h index 71412a61550..22484704550 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp.h +++ b/tiledb/sm/serialization/tiledb-rest.capnp.h @@ -70,7 +70,6 @@ CAPNP_DECLARE_SCHEMA(afcbef694e73edb8); CAPNP_DECLARE_SCHEMA(def87cead82188e7); CAPNP_DECLARE_SCHEMA(c1a2d010de779de5); CAPNP_DECLARE_SCHEMA(c86c77b5f6a2bf0f); -CAPNP_DECLARE_SCHEMA(818a8600b3452aa4); CAPNP_DECLARE_SCHEMA(9b9a5fc7713a8692); CAPNP_DECLARE_SCHEMA(96ba49d0f8b23ccc); CAPNP_DECLARE_SCHEMA(9df6f2a42c4e5f0b); @@ -1049,23 +1048,6 @@ struct ReadStateIndex { }; }; -struct PreprocessTileOrder { - PreprocessTileOrder() = delete; - - class Reader; - class Builder; - class Pipeline; - - struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(818a8600b3452aa4, 1, 1) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE - }; -}; - struct ReaderIndex { ReaderIndex() = delete; @@ -1074,7 +1056,7 @@ struct ReaderIndex { class Pipeline; struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(9b9a5fc7713a8692, 0, 6) + CAPNP_DECLARE_STRUCT_HEADER(9b9a5fc7713a8692, 0, 5) #if !CAPNP_LITE static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; @@ -9292,124 +9274,6 @@ class ReadStateIndex::Pipeline { }; #endif // !CAPNP_LITE -class PreprocessTileOrder::Reader { - public: - typedef PreprocessTileOrder Reads; - - Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } - - inline ::capnp::MessageSize totalSize() const { - return _reader.totalSize().asPublic(); - } - -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); - } -#endif // !CAPNP_LITE - - inline ::uint64_t getCursor() const; - - inline bool hasTiles() const; - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>::Reader - getTiles() const; - - private: - ::capnp::_::StructReader _reader; - template - friend struct ::capnp::ToDynamic_; - template - friend struct ::capnp::_::PointerHelpers; - template - friend struct ::capnp::List; - friend class ::capnp::MessageBuilder; - friend class ::capnp::Orphanage; -}; - -class PreprocessTileOrder::Builder { - public: - typedef PreprocessTileOrder Builds; - - Builder() = delete; // Deleted to discourage incorrect usage. - // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } - - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } -#endif // !CAPNP_LITE - - inline ::uint64_t getCursor(); - inline void setCursor(::uint64_t value); - - inline bool hasTiles(); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>::Builder - getTiles(); - inline void setTiles(::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>::Reader value); - inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>::Builder - initTiles(unsigned int size); - inline void adoptTiles(::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>>&& value); - inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>> - disownTiles(); - - private: - ::capnp::_::StructBuilder _builder; - template - friend struct ::capnp::ToDynamic_; - friend class ::capnp::Orphanage; - template - friend struct ::capnp::_::PointerHelpers; -}; - -#if !CAPNP_LITE -class PreprocessTileOrder::Pipeline { - public: - typedef PreprocessTileOrder Pipelines; - - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } - inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - private: - ::capnp::AnyPointer::Pipeline _typeless; - friend class ::capnp::PipelineHook; - template - friend struct ::capnp::ToDynamic_; -}; -#endif // !CAPNP_LITE - class ReaderIndex::Reader { public: typedef ReaderIndex Reads; @@ -9447,10 +9311,6 @@ class ReaderIndex::Reader { inline bool hasStats() const; inline ::tiledb::sm::serialization::capnp::Stats::Reader getStats() const; - inline bool hasPreprocess() const; - inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Reader - getPreprocess() const; - private: ::capnp::_::StructReader _reader; template @@ -9539,20 +9399,6 @@ class ReaderIndex::Builder { inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::Stats> disownStats(); - inline bool hasPreprocess(); - inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Builder - getPreprocess(); - inline void setPreprocess( - ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Reader value); - inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Builder - initPreprocess(); - inline void adoptPreprocess( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::PreprocessTileOrder>&& - value); - inline ::capnp::Orphan< - ::tiledb::sm::serialization::capnp::PreprocessTileOrder> - disownPreprocess(); - private: ::capnp::_::StructBuilder _builder; template @@ -9579,8 +9425,6 @@ class ReaderIndex::Pipeline { getReadState(); inline ::tiledb::sm::serialization::capnp::Condition::Pipeline getCondition(); inline ::tiledb::sm::serialization::capnp::Stats::Pipeline getStats(); - inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Pipeline - getPreprocess(); private: ::capnp::AnyPointer::Pipeline _typeless; @@ -25947,94 +25791,6 @@ inline void ReadStateIndex::Builder::setDoneAddingResultTiles(bool value) { _builder.setDataField(::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } -inline ::uint64_t PreprocessTileOrder::Reader::getCursor() const { - return _reader.getDataField<::uint64_t>( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); -} - -inline ::uint64_t PreprocessTileOrder::Builder::getCursor() { - return _builder.getDataField<::uint64_t>( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); -} -inline void PreprocessTileOrder::Builder::setCursor(::uint64_t value) { - _builder.setDataField<::uint64_t>( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); -} - -inline bool PreprocessTileOrder::Reader::hasTiles() const { - return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline bool PreprocessTileOrder::Builder::hasTiles() { - return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) - .isNull(); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>::Reader -PreprocessTileOrder::Reader::getTiles() const { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>>::get(_reader - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>::Builder -PreprocessTileOrder::Builder::getTiles() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>>::get(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} -inline void PreprocessTileOrder::Builder::setTiles( - ::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>::Reader value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>>:: - set(_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - value); -} -inline ::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>::Builder -PreprocessTileOrder::Builder::initTiles(unsigned int size) { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>>:: - init( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - size); -} -inline void PreprocessTileOrder::Builder::adoptTiles( - ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>>&& value) { - ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>>:: - adopt( - _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>> -PreprocessTileOrder::Builder::disownTiles() { - return ::capnp::_::PointerHelpers<::capnp::List< - ::tiledb::sm::serialization::capnp::ResultTileId, - ::capnp::Kind::STRUCT>>::disown(_builder - .getPointerField( - ::capnp::bounded<0>() * - ::capnp::POINTERS)); -} - inline bool ReaderIndex::Reader::hasLayout() const { return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) .isNull(); @@ -26284,63 +26040,6 @@ ReaderIndex::Builder::disownStats() { _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS)); } -inline bool ReaderIndex::Reader::hasPreprocess() const { - return !_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); -} -inline bool ReaderIndex::Builder::hasPreprocess() { - return !_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS) - .isNull(); -} -inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Reader -ReaderIndex::Reader::getPreprocess() const { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::PreprocessTileOrder>:: - get(_reader.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Builder -ReaderIndex::Builder::getPreprocess() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::PreprocessTileOrder>:: - get(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Pipeline -ReaderIndex::Pipeline::getPreprocess() { - return ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Pipeline( - _typeless.getPointerField(5)); -} -#endif // !CAPNP_LITE -inline void ReaderIndex::Builder::setPreprocess( - ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Reader value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::PreprocessTileOrder>:: - set(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - value); -} -inline ::tiledb::sm::serialization::capnp::PreprocessTileOrder::Builder -ReaderIndex::Builder::initPreprocess() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::PreprocessTileOrder>:: - init(_builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); -} -inline void ReaderIndex::Builder::adoptPreprocess( - ::capnp::Orphan<::tiledb::sm::serialization::capnp::PreprocessTileOrder>&& - value) { - ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::PreprocessTileOrder>:: - adopt( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS), - kj::mv(value)); -} -inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::PreprocessTileOrder> -ReaderIndex::Builder::disownPreprocess() { - return ::capnp::_::PointerHelpers< - ::tiledb::sm::serialization::capnp::PreprocessTileOrder>:: - disown( - _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS)); -} - inline bool Query::Reader::hasAttributeBufferHeaders() const { return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) .isNull(); From b19ee2ec66a0d1562053a995c2921eaa7517398f Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 27 Jan 2025 16:05:48 -0500 Subject: [PATCH 196/228] fragment skew add another shrink example --- test/src/unit-sparse-global-order-reader.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index dec8875f84a..8418c3f959a 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -1308,6 +1308,8 @@ TEST_CASE_METHOD( 2, 1, 1, {templates::Domain(1, 1)}); doit.operator()( 2, 1, 1, {templates::Domain(1, 2)}); + doit.operator()( + 39, 1, 1, {templates::Domain(20, 21)}); } SECTION("Rapidcheck") { From e34929d17b458ac4983dac2c57b398bef142d335 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Mon, 27 Jan 2025 16:06:08 -0500 Subject: [PATCH 197/228] Change dump_durations to have ostream arg --- test/performance/tiledb_submit_a_b.cc | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 206556b7de5..5d204f8eab6 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -174,9 +174,7 @@ struct StatKeeper { /** * Write durations to a file for analysis. */ - void dump_durations(const char* path) const { - std::ofstream dump(path); - + void dump_durations(std::ostream& dump) const { json arrays; for (const auto& uri : statistics) { @@ -655,7 +653,8 @@ int main(int argc, char** argv) { tiledb_config_free(&b_conf); tiledb_config_free(&a_conf); - stat_keeper.dump_durations("/tmp/tiledb_submit_a_b.json"); + std::ofstream out("/tmp/tiledb_submit_a_b.json"); + stat_keeper.dump_durations(out); return 0; } From 19e016d6a7fc6378d4846c2854fbf2fd3ef6e5b5 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 28 Jan 2025 13:44:06 -0500 Subject: [PATCH 198/228] Remove redundant CMakeLists dependency --- test/performance/CMakeLists.txt | 2 -- 1 file changed, 2 deletions(-) diff --git a/test/performance/CMakeLists.txt b/test/performance/CMakeLists.txt index efdc9ee5b8a..ca927114ccf 100644 --- a/test/performance/CMakeLists.txt +++ b/test/performance/CMakeLists.txt @@ -106,8 +106,6 @@ add_executable( "tiledb_submit_a_b.cc" ) -add_dependencies(tiledb_submit_a_b tiledb_test_support_lib) - target_include_directories( tiledb_submit_a_b BEFORE PRIVATE ${TILEDB_CORE_INCLUDE_DIR} From 9f833f22c91099e47a53aa2be7159370ae47aca9 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 28 Jan 2025 13:44:35 -0500 Subject: [PATCH 199/228] Stats::get_timer and Stats::find_timer --- tiledb/sm/stats/stats.cc | 25 +++++++++++++++++++++++++ tiledb/sm/stats/stats.h | 7 +++++++ 2 files changed, 32 insertions(+) diff --git a/tiledb/sm/stats/stats.cc b/tiledb/sm/stats/stats.cc index 6c439866cbc..a2330b367c1 100644 --- a/tiledb/sm/stats/stats.cc +++ b/tiledb/sm/stats/stats.cc @@ -214,6 +214,31 @@ std::optional Stats::find_counter(const std::string& stat) const { return std::nullopt; } +std::optional Stats::get_timer(const std::string& stat) const { + const std::string new_stat = prefix_ + stat; + std::unique_lock lck(mtx_); + auto maybe = timers_.find(new_stat); + if (maybe == timers_.end()) { + return std::nullopt; + } else { + return maybe->second; + } +} + +std::optional Stats::find_timer(const std::string& stat) const { + const auto mine = get_timer(stat); + if (mine.has_value()) { + return mine; + } + for (const auto& child : children_) { + const auto theirs = child.find_timer(stat); + if (theirs.has_value()) { + return theirs; + } + } + return std::nullopt; +} + DurationInstrument Stats::start_timer(const std::string& stat) { return DurationInstrument(*this, stat); } diff --git a/tiledb/sm/stats/stats.h b/tiledb/sm/stats/stats.h index f978c289f01..5f375bfb261 100644 --- a/tiledb/sm/stats/stats.h +++ b/tiledb/sm/stats/stats.h @@ -170,6 +170,13 @@ class Stats { * and returns its value */ std::optional find_counter(const std::string& stat) const; + /** Returns the value of the timer for `stat`, if any */ + std::optional get_timer(const std::string& stat) const; + + /** Searches through the child stats to find a timer with the given name, + * and returns its value */ + std::optional find_timer(const std::string& stat) const; + /** Returns true if statistics are currently enabled. */ bool enabled() const; From 76ead2110fd1235b2c1c67c9a6f955f41fadeb71 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 28 Jan 2025 13:45:26 -0500 Subject: [PATCH 200/228] Time the parallel merge init and await --- .../readers/sparse_global_order_reader.cc | 20 +++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 6a4c65ce03a..deb2cfde4dc 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -77,10 +77,14 @@ class SparseGlobalOrderReaderInternalError struct PreprocessTileMergeFuture { using MemoryCounter = std::atomic; - PreprocessTileMergeFuture(MemoryCounter& memory_used) - : memory_used_(memory_used) { + PreprocessTileMergeFuture(Stats& stats, MemoryCounter& memory_used) + : stats_(stats) + , memory_used_(memory_used) { } + /** Query timers and metrics */ + Stats& stats_; + /** memory used for result tile IDs */ MemoryCounter& memory_used_; @@ -114,7 +118,12 @@ struct PreprocessTileMergeFuture { if (!merge_.has_value()) { return std::nullopt; } - auto ret = merge_.value()->await(); + std::optional ret; + { + auto timer_await = + stats_.start_timer("preprocess_result_tile_order_await"); + ret = merge_.value()->await(); + } if (merge_.value()->finished()) { free_input(); } @@ -285,7 +294,7 @@ Status SparseGlobalOrderReader::dowork() { // are serialized back and forth; and then this happens again once the // end of the list is reached (at which point it is cleared), if more // iterations are needed. - preprocess_future.emplace(memory_used_for_coords_total_); + preprocess_future.emplace(*stats_, memory_used_for_coords_total_); preprocess_compute_result_tile_order(preprocess_future.value()); preprocess_set_cursor_from_read_state(preprocess_future.value()); } else if (preprocess_tile_order_.enabled_) { @@ -640,6 +649,9 @@ bool SparseGlobalOrderReader::add_result_tile( template void SparseGlobalOrderReader::preprocess_compute_result_tile_order( PreprocessTileMergeFuture& future) { + auto timer_start_tile_order = + stats_->start_timer("preprocess_result_tile_order_compute"); + const auto& relevant_fragments = subarray_.relevant_fragments(); const uint64_t num_relevant_fragments = relevant_fragments.size(); From e20d6b324d8168791adf7a000e61f141dfaf95f1 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 28 Jan 2025 13:45:51 -0500 Subject: [PATCH 201/228] tiledb_submit_a_b report parallel merge timers --- test/performance/tiledb_submit_a_b.cc | 32 +++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 5d204f8eab6..589283423ac 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -171,6 +171,16 @@ struct StatKeeper { } } + void report_timer( + const StatKey& stat, const std::string& name, const json& value) { + auto& stats = statistics[stat.uri_][stat.qlabel_]; + if (stat.is_a_) { + stats.first.metrics[name] = value; + } else { + stats.second.metrics[name] = value; + } + } + /** * Write durations to a file for analysis. */ @@ -590,6 +600,28 @@ static void run( b_key, "internal_loop_num", optional_json(b_stats.find_counter("internal_loop_num"))); + + // record parallel merge timers + stat_keeper.report_timer( + a_key, + "preprocess_result_tile_order_compute", + optional_json( + a_stats.find_timer("preprocess_result_tile_order_compute.sum"))); + stat_keeper.report_timer( + a_key, + "preprocess_result_tile_order_await", + optional_json( + a_stats.find_timer("preprocess_result_tile_order_await.sum"))); + stat_keeper.report_timer( + b_key, + "preprocess_result_tile_order_compute", + optional_json( + b_stats.find_timer("preprocess_result_tile_order_compute.sum"))); + stat_keeper.report_timer( + b_key, + "preprocess_result_tile_order_await", + optional_json( + b_stats.find_timer("preprocess_result_tile_order_await.sum"))); } // change this to match the schema of the target arrays From 3f44e7629c8e7277105cf9441a12c1393181caac Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 28 Jan 2025 16:29:19 -0500 Subject: [PATCH 202/228] Update default min merge items to 32768 --- tiledb/api/c_api/config/config_api_external.h | 2 +- tiledb/sm/config/config.cc | 2 +- tiledb/sm/cpp_api/config.h | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/tiledb/api/c_api/config/config_api_external.h b/tiledb/api/c_api/config/config_api_external.h index fbc0c9a4597..d368081832c 100644 --- a/tiledb/api/c_api/config/config_api_external.h +++ b/tiledb/api/c_api/config/config_api_external.h @@ -265,7 +265,7 @@ TILEDB_EXPORT void tiledb_config_free(tiledb_config_t** config) TILEDB_NOEXCEPT; * there are many fragments or when the distribution in space of the * tiles amongst the fragments is skewed. The value of the parameter * specifies the amount of work per parallel task. - * **Default**: "128" + * **Default**: "32768" * - `sm.query.sparse_unordered_with_dups.reader`
* Which reader to use for sparse unordered with dups queries. * "refactored" or "legacy".
diff --git a/tiledb/sm/config/config.cc b/tiledb/sm/config/config.cc index 6579306dcc1..1d434704df8 100644 --- a/tiledb/sm/config/config.cc +++ b/tiledb/sm/config/config.cc @@ -119,7 +119,7 @@ const std::string Config::SM_QUERY_DENSE_QC_COORDS_MODE = "false"; const std::string Config::SM_QUERY_DENSE_READER = "refactored"; const std::string Config::SM_QUERY_SPARSE_GLOBAL_ORDER_READER = "refactored"; const std::string Config::SM_QUERY_SPARSE_GLOBAL_ORDER_PREPROCESS_TILE_MERGE = - "128"; + "32768"; const std::string Config::SM_QUERY_SPARSE_UNORDERED_WITH_DUPS_READER = "refactored"; const std::string Config::SM_MEM_MALLOC_TRIM = "true"; diff --git a/tiledb/sm/cpp_api/config.h b/tiledb/sm/cpp_api/config.h index 80ffb7c32c9..2050cfc69b1 100644 --- a/tiledb/sm/cpp_api/config.h +++ b/tiledb/sm/cpp_api/config.h @@ -437,7 +437,7 @@ class Config { * there are many fragments or when the distribution in space of the * tiles amongst the fragments is skewed. The value of the parameter * specifies the amount of work per parallel task. - * **Default**: "128" + * **Default**: "32768" * - `sm.query.sparse_unordered_with_dups.reader`
* Which reader to use for sparse unordered with dups queries. * "refactored" or "legacy".
From 544eda17325d5389814b571ac6e790733a44cf0f Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 29 Jan 2025 21:55:20 -0500 Subject: [PATCH 203/228] ResultTileId constructor --- test/src/unit-sparse-global-order-reader.cc | 3 +-- tiledb/sm/query/readers/result_tile.h | 7 +++++++ tiledb/sm/query/readers/sparse_global_order_reader.cc | 9 +++------ 3 files changed, 11 insertions(+), 8 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 8418c3f959a..4f366c81257 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -965,8 +965,7 @@ static std::optional can_complete_in_memory_budget( for (unsigned f = 0; f < instance.fragments.size(); f++) { for (uint64_t t = 0; t < fragment_metadata[f]->tile_num(); t++) { if (instance.intersects(fragment_metadata[f]->mbr(t))) { - mbr_lower_bound.push( - sm::ResultTileId{.fragment_idx_ = f, .tile_idx_ = t}); + mbr_lower_bound.push(sm::ResultTileId(f, t)); } } } diff --git a/tiledb/sm/query/readers/result_tile.h b/tiledb/sm/query/readers/result_tile.h index ec39118abb7..afc1a26f91b 100644 --- a/tiledb/sm/query/readers/result_tile.h +++ b/tiledb/sm/query/readers/result_tile.h @@ -73,6 +73,13 @@ bool result_tile_cmp(const ResultTile* a, const ResultTile* b); struct ResultTileId { unsigned fragment_idx_; uint64_t tile_idx_; + + ResultTileId() = default; + + ResultTileId(unsigned fragment_idx, uint64_t tile_idx) + : fragment_idx_(fragment_idx) + , tile_idx_(tile_idx) { + } }; /** diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index deb2cfde4dc..9fbe19445b5 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -690,8 +690,7 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( RETURN_NOT_OK(try_reserve(f, num_tiles)); for (uint64_t t = 0; t < fragment_metadata_[f]->tile_num(); t++) { - fragment_result_tiles[f].push_back( - ResultTileId{.fragment_idx_ = f, .tile_idx_ = t}); + fragment_result_tiles[f].push_back(ResultTileId(f, t)); } return Status::Ok(); }); @@ -716,8 +715,7 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( tile_range != fragment_tile_ranges.rend(); ++tile_range) { for (uint64_t t = tile_range->first; t <= tile_range->second; t++) { - fragment_result_tiles[f].push_back( - ResultTileId{.fragment_idx_ = f, .tile_idx_ = t}); + fragment_result_tiles[f].push_back(ResultTileId(f, t)); } } @@ -753,8 +751,7 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( } /* then do parallel merge */ - preprocess_tile_order_.tiles_.resize( - num_result_tiles, ResultTileId{.fragment_idx_ = 0, .tile_idx_ = 0}); + preprocess_tile_order_.tiles_.resize(num_result_tiles, ResultTileId(0, 0)); const auto min_merge_items = config_ From 007ab674009b71a17ef9afe44520982e112387e7 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 30 Jan 2025 14:04:57 -0500 Subject: [PATCH 204/228] tiledb_submit_a_b named configurations, config num_user_cells, and use C++ API in some parts for better exception handling --- test/performance/tiledb_submit_a_b.cc | 427 ++++++++++++-------------- 1 file changed, 198 insertions(+), 229 deletions(-) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 589283423ac..693ee31a4e0 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -32,11 +32,12 @@ * * Usage: $0 [additional array URIs...] * - * For each array in the argument list, two queries are created: - * one with configuration "A" and one with configuration "B". + * For each array in the argument list, a query is created for each + * of the configurations in "configurations". * The `run()` function alternates taking a step (`tiledb_query_submit`) - * with the "A" query and the "B" query, checking that both have the - * same results and recording the time spent calling `tiledb_query_submit`. + * with a query of each of those configurations, checking that they all + * have the same results, and recording various metrics from each + * (most notably, the time spent calling `tiledb_query_submit`) * * After executing upon all of the arrays, the timing information is * dumped to `/tmp/tiledb_submit_a_b.json`. @@ -46,22 +47,28 @@ * this file. The `using Fragment` declaration sets the types of the buffers * which are used to read the array. * - * The nature of the "A" and "B" configurations are specified via the required + * The nature of different configurations are specified via the required * argument `config.json`. The following example illustrates the currently * supported keys: * * ``` * { - * "a": { - * "config": { - * "sm.query.sparse_global_order.preprocess_tile_merge": 0 - * } - * }, - * "b": { - * "config": { - * "sm.query.sparse_global_order.preprocess_tile_merge": 128 - * } - * }, + * "configurations": [ + * { + * "name": "a", + * "num_user_cells": 16777216, + * "config": { + * "sm.query.sparse_global_order.preprocess_tile_merge": 0 + * } + * }, + * { + * "name": "b", + * "num_user_cells: 16777216 + * "config": { + * "sm.query.sparse_global_order.preprocess_tile_merge": 128 + * } + * }, + * ], * "queries": [ * { * "layout": "global_order", @@ -75,8 +82,10 @@ * } * ``` * - * The paths "a.config" and "b.config" are sets of key-value pairs - * which are used to configure the "A" and "B" queries respectively. + * The "config" field of each configuration object is a set of key-value + * pairs which are set on a `tileb::Config` object for instances + * of each query. The "name" field identifies the configuration; + * and the "num_user_cells" field sets the size of the user buffer. * * Each item in "queries" specifies a query to run the comparison for. * @@ -99,6 +108,7 @@ #include "tiledb/sm/array_schema/array_schema.h" #include "tiledb/sm/array_schema/attribute.h" #include "tiledb/sm/array_schema/dimension.h" +#include "tiledb/sm/cpp_api/tiledb" #include "tiledb/sm/misc/comparators.h" #include "tiledb/sm/stats/duration_instrument.h" #include "tiledb/type/apply_with_type.h" @@ -125,6 +135,12 @@ json optional_json(std::optional value) { } } +struct Configuration { + std::string name_; + std::optional num_user_cells_; + tiledb::Config qconf_; +}; + /** * Records durations as reported by `tiledb::sm::stats::DurationInstrument`. */ @@ -132,7 +148,7 @@ struct StatKeeper { struct StatKey { std::string uri_; std::string qlabel_; - bool is_a_; + std::string configname_; }; struct StatValue { @@ -143,7 +159,7 @@ struct StatKeeper { using Timer = tiledb::sm::stats::DurationInstrument; /** records statistics of each submit call by "array.query" */ - std::map>> + std::map>> statistics; Timer start_timer(const StatKey& stat) { @@ -153,32 +169,20 @@ struct StatKeeper { void report_duration( const StatKey& stat, const std::chrono::duration duration) { - auto& stats = statistics[stat.uri_][stat.qlabel_]; - if (stat.is_a_) { - stats.first.durations.push_back(duration.count()); - } else { - stats.second.durations.push_back(duration.count()); - } + auto& stats = statistics[stat.uri_][stat.qlabel_][stat.configname_]; + stats.durations.push_back(duration.count()); } void report_metric( const StatKey& stat, const std::string& name, const json& value) { - auto& stats = statistics[stat.uri_][stat.qlabel_]; - if (stat.is_a_) { - stats.first.metrics[name] = value; - } else { - stats.second.metrics[name] = value; - } + auto& stats = statistics[stat.uri_][stat.qlabel_][stat.configname_]; + stats.metrics[name] = value; } void report_timer( const StatKey& stat, const std::string& name, const json& value) { - auto& stats = statistics[stat.uri_][stat.qlabel_]; - if (stat.is_a_) { - stats.first.metrics[name] = value; - } else { - stats.second.metrics[name] = value; - } + auto& stats = statistics[stat.uri_][stat.qlabel_][stat.configname_]; + stats.metrics[name] = value; } /** @@ -192,31 +196,22 @@ struct StatKeeper { array["uri"] = uri.first; for (const auto& qlabel : uri.second) { - const auto& a_durations = qlabel.second.first.durations; - const auto& b_durations = qlabel.second.second.durations; - const double a_sum = - std::accumulate(a_durations.begin(), a_durations.end(), (double)0); - const double b_sum = - std::accumulate(b_durations.begin(), b_durations.end(), (double)0); - - json a; - a["first"] = a_durations[0]; - a["sum"] = a_sum; - for (const auto& metric : qlabel.second.first.metrics) { - a[metric.first] = metric.second; - } - - json b; - b["first"] = b_durations[0]; - b["sum"] = b_sum; - for (const auto& metric : qlabel.second.second.metrics) { - b[metric.first] = metric.second; - } - json run; run["query"] = qlabel.first; - run["a"] = a; - run["b"] = b; + for (const auto& config : qlabel.second) { + json query; + query["first"] = config.second.durations[0]; + query["sum"] = std::accumulate( + config.second.durations.begin(), + config.second.durations.end(), + (double)(0)); + + for (const auto& metric : config.second.metrics) { + query[metric.first] = metric.second; + } + + run[config.first] = query; + } array["queries"].push_back(run); } @@ -228,36 +223,29 @@ struct StatKeeper { } }; -capi_return_t shrink_domain( - tiledb_ctx_t* ctx, - tiledb_array_t* array, +void shrink_domain( + tiledb::Array& array, unsigned dim, - tiledb_subarray_t* subarray, + tiledb::Subarray& subarray, int percent) { // FIXME: make generic - int is_empty; int64_t domain[2]; - RETURN_IF_ERR(tiledb_array_get_non_empty_domain_from_index( - ctx, array, dim, &domain[0], &is_empty)); - if (is_empty) { - return TILEDB_OK; - } + std::tie(domain[0], domain[1]) = array.non_empty_domain(dim); const auto span = (domain[1] - domain[0] + 1); domain[0] += ((span * (100 - percent)) / 100) / 2; domain[1] -= ((span * (100 - percent)) / 100) / 2; - return tiledb_subarray_add_range( - ctx, subarray, dim, &domain[0], &domain[1], 0); + subarray.add_range(dim, domain[0], domain[1]); } -struct QueryConfig { +struct Query { std::string label_; tiledb_layout_t layout_; std::vector> subarray_percent_; - static QueryConfig from_json(const json& jq) { - QueryConfig q; + static Query from_json(const json& jq) { + Query q; q.label_ = jq["label"].get(); const auto layout = jq["layout"].get(); @@ -297,44 +285,35 @@ struct QueryConfig { /** * Applies this configuration to a query. */ - capi_return_t apply( - tiledb_ctx_t* ctx, tiledb_array_t* array, tiledb_query_t* query) const { - TRY(ctx, tiledb_query_set_layout(ctx, query, layout_)); + void apply( + tiledb::Context& ctx, tiledb::Array& array, tiledb::Query& query) const { + query.set_layout(layout_); if (!subarray_percent_.empty()) { - tiledb_subarray_t* subarray; - RETURN_IF_ERR(tiledb_subarray_alloc(ctx, array, &subarray)); - - tiledb_array_schema_t* schema; - RETURN_IF_ERR(tiledb_array_get_schema(ctx, array, &schema)); + tiledb::Subarray subarray(ctx, array); - tiledb_domain_t* domain; - RETURN_IF_ERR(tiledb_array_schema_get_domain(ctx, schema, &domain)); + tiledb::ArraySchema schema = array.schema(); for (unsigned d = 0; d < subarray_percent_.size(); d++) { if (subarray_percent_[d].has_value()) { - TRY(ctx, - shrink_domain( - ctx, array, d, subarray, subarray_percent_[d].value())); + shrink_domain(array, d, subarray, subarray_percent_[d].value()); } } - TRY(ctx, tiledb_query_set_subarray_t(ctx, query, subarray)); + query.set_subarray(subarray); } - - return TILEDB_OK; } }; template tiledb::common::Status assertGlobalOrder( - tiledb_array_t* array, + const tiledb::Array& array, const Fragment& data, size_t num_cells, size_t start, size_t end) { tiledb::sm::GlobalCellCmp globalcmp( - array->array()->array_schema_latest().domain()); + array.ptr()->array()->array_schema_latest().domain()); for (uint64_t i = start + 1; i < end; i++) { const auto prevtuple = std::apply( @@ -384,14 +363,14 @@ struct require_type { }; template -static void check_compatibility(tiledb_array_t* array) { +static void check_compatibility(const tiledb::Array& array) { using DimensionTuple = decltype(std::declval().dimensions()); using AttributeTuple = decltype(std::declval().attributes()); constexpr auto expect_num_dims = std::tuple_size_v; constexpr auto max_num_atts = std::tuple_size_v; - const auto& schema = array->array()->array_schema_latest(); + const auto& schema = array.ptr()->array()->array_schema_latest(); if (schema.domain().dim_num() != expect_num_dims) { throw std::runtime_error( @@ -424,76 +403,66 @@ template static void run( StatKeeper& stat_keeper, const char* array_uri, - const QueryConfig& query_config, - tiledb_config_t* a_config, - tiledb_config_t* b_config) { + const Query& query_config, + const std::span configs) { tiledb::test::SparseGlobalOrderReaderMemoryBudget memory; memory.total_budget_ = std::to_string(1024 * 1024 * 1024); memory.ratio_tile_ranges_ = "0.01"; - const uint64_t num_user_cells = 1024 * 1024 * 128; + std::vector num_user_cells; + for (const auto& config : configs) { + num_user_cells.push_back( + config.num_user_cells_.value_or(1024 * 1024 * 128)); + } - Fragment a_data; - Fragment b_data; + std::vector qdata(configs.size()); - auto reset = [num_user_cells](Fragment& buf) { + auto reset = [&](size_t q) { std::apply( - [&](auto&... outfield) { (outfield.resize(num_user_cells), ...); }, - std::tuple_cat(buf.dimensions(), buf.attributes())); + [&](auto&... outfield) { (outfield.resize(num_user_cells[q]), ...); }, + std::tuple_cat(qdata[q].dimensions(), qdata[q].attributes())); }; - reset(a_data); - reset(b_data); - - tiledb_config_t* config; - { - tiledb_error_t* error = nullptr; - ASSERTER(tiledb_config_alloc(&config, &error) == TILEDB_OK); + for (size_t q = 0; q < qdata.size(); q++) { + reset(q); } - memory.apply(config); - tiledb_ctx_t* ctx; - ASSERTER(tiledb_ctx_alloc(config, &ctx) == TILEDB_OK); + tiledb::Config memconfig; + memory.apply(memconfig.ptr().get()); - tiledb_config_free(&config); + tiledb::Context ctx(memconfig); // Open array for reading. - CApiArray array(ctx, array_uri, TILEDB_READ); + tiledb::Array array(ctx, array_uri, TILEDB_READ); check_compatibility(array); auto dimension_name = [&](unsigned d) -> std::string { return std::string( - array->array_schema_latest().domain().dimension_ptr(d)->name()); + array.ptr()->array_schema_latest().domain().dimension_ptr(d)->name()); }; auto attribute_name = [&](unsigned a) -> std::string { - return std::string(array->array_schema_latest().attribute(a)->name()); + return std::string(array.ptr()->array_schema_latest().attribute(a)->name()); }; - // Create query which does NOT do merge - tiledb_query_t* a_query; - TRY(ctx, tiledb_query_alloc(ctx, array, TILEDB_READ, &a_query)); - TRY(ctx, tiledb_query_set_config(ctx, a_query, a_config)); - TRY(ctx, query_config.apply(ctx, array, a_query)); - - // Create query which DOES do merge - tiledb_query_t* b_query; - TRY(ctx, tiledb_query_alloc(ctx, array, TILEDB_READ, &b_query)); - TRY(ctx, tiledb_query_set_config(ctx, b_query, b_config)); - TRY(ctx, query_config.apply(ctx, array, b_query)); - - const StatKeeper::StatKey a_key = { - .uri_ = std::string(array_uri), - .qlabel_ = query_config.label_, - .is_a_ = true, - }; - const StatKeeper::StatKey b_key = { - .uri_ = std::string(array_uri), - .qlabel_ = query_config.label_, - .is_a_ = false, - }; + std::vector queries; + for (const auto& config : configs) { + tiledb::Query query(ctx, array, TILEDB_READ); + query.set_config(config.qconf_); + query_config.apply(ctx, array, query); + + queries.push_back(query); + } + + std::vector keys; + for (const auto& config : configs) { + keys.push_back(StatKeeper::StatKey{ + .uri_ = std::string(array_uri), + .qlabel_ = query_config.label_, + .configname_ = config.name_}); + } // helper to do basic checks on both auto do_submit = [&](auto& key, auto& query, auto& outdata) - -> std::pair { + -> std::pair { // make field size locations auto dimension_sizes = templates::query::make_field_sizes(outdata.dimensions()); @@ -502,18 +471,24 @@ static void run( // add fields to query templates::query::set_fields( - ctx, query, dimension_sizes, outdata.dimensions(), dimension_name); + ctx.ptr().get(), + query.ptr().get(), + dimension_sizes, + outdata.dimensions(), + dimension_name); templates::query::set_fields( - ctx, query, attribute_sizes, outdata.attributes(), attribute_name); + ctx.ptr().get(), + query.ptr().get(), + attribute_sizes, + outdata.attributes(), + attribute_name); + tiledb::Query::Status status; { StatKeeper::Timer qtimer = stat_keeper.start_timer(key); - TRY(ctx, tiledb_query_submit(ctx, query)); + status = query.submit(); } - tiledb_query_status_t status; - TRY(ctx, tiledb_query_get_status(ctx, query, &status)); - const uint64_t dim_num_cells = templates::query::num_cells( outdata.dimensions(), dimension_sizes); const uint64_t att_num_cells = templates::query::num_cells( @@ -523,105 +498,96 @@ static void run( if (dim_num_cells < outdata.size()) { // since the user buffer did not fill up the query must be complete - ASSERTER(status == TILEDB_COMPLETED); + ASSERTER(status == tiledb::Query::Status::COMPLETE); } return std::make_pair(status, dim_num_cells); }; while (true) { - tiledb_query_status_t a_status, b_status; - uint64_t a_num_cells, b_num_cells; + std::vector status; + std::vector num_cells; - std::tie(a_status, a_num_cells) = do_submit(a_key, a_query, a_data); - std::tie(b_status, b_num_cells) = do_submit(b_key, b_query, b_data); + for (size_t q = 0; q < queries.size(); q++) { + auto result = do_submit(keys[q], queries[q], qdata[q]); + status.push_back(result.first); + num_cells.push_back(result.second); + } - ASSERTER(a_num_cells == b_num_cells); - ASSERTER(a_num_cells <= num_user_cells); + for (size_t q = 0; q < queries.size(); q++) { + std::apply( + [&](auto&... outfield) { (outfield.resize(num_cells[0]), ...); }, + std::tuple_cat(qdata[q].dimensions(), qdata[q].attributes())); - std::apply( - [&](auto&... outfield) { (outfield.resize(a_num_cells), ...); }, - std::tuple_cat(a_data.dimensions(), a_data.attributes())); - std::apply( - [&](auto&... outfield) { (outfield.resize(b_num_cells), ...); }, - std::tuple_cat(b_data.dimensions(), b_data.attributes())); + ASSERTER(num_cells[q] <= num_user_cells[q]); - ASSERTER(a_data.dimensions() == b_data.dimensions()); + if (q > 0) { + ASSERTER(num_cells[q] == num_cells[0]); + ASSERTER(qdata[q].dimensions() == qdata[0].dimensions()); - // NB: this is only correct if there are no duplicate coordinates, - // in which case we need to adapt what CSparseGlobalOrderFx::run does - ASSERTER(a_data.attributes() == b_data.attributes()); + // NB: this is only correct if there are no duplicate coordinates, + // in which case we need to adapt what CSparseGlobalOrderFx::run does + ASSERTER(qdata[q].attributes() == qdata[0].attributes()); + } + } - reset(a_data); - reset(b_data); + for (size_t q = 0; q < queries.size(); q++) { + reset(q); + } - ASSERTER(a_status == b_status); + for (size_t q = 1; q < queries.size(); q++) { + ASSERTER(status[q] == status[0]); + } - if (a_query->query_->layout() == tiledb::sm::Layout::GLOBAL_ORDER) { + if (queries[0].query_layout() == TILEDB_GLOBAL_ORDER) { // assert that the results arrive in global order // do it in parallel, it is slow - auto* tp = ctx->context().compute_tp(); + auto* tp = ctx.ptr()->context().compute_tp(); const size_t parallel_factor = std::max( - 1, std::min(tp->concurrency_level(), a_num_cells / 1024)); - const size_t items_per = a_num_cells / parallel_factor; - const auto isGlobalOrder = tiledb::sm::parallel_for( - ctx->context().compute_tp(), 0, parallel_factor, [&](uint64_t i) { + 1, std::min(tp->concurrency_level(), num_cells[0] / 1024)); + const size_t items_per = num_cells[0] / parallel_factor; + const auto isGlobalOrder = + tiledb::sm::parallel_for(tp, 0, parallel_factor, [&](uint64_t i) { const uint64_t mystart = i * items_per; const uint64_t myend = - std::min((i + 1) * items_per + 1, a_num_cells); + std::min((i + 1) * items_per + 1, num_cells[0]); return assertGlobalOrder( - array, a_data, a_num_cells, mystart, myend); + array, qdata[0], num_cells[0], mystart, myend); }); if (!isGlobalOrder.ok()) { throw std::runtime_error(isGlobalOrder.to_string()); } } - if (a_status == TILEDB_COMPLETED) { + if (status[0] == tiledb::Query::Status::COMPLETE) { break; } } // record additional stats - const tiledb::sm::Query& a_query_internal = *a_query->query_; - const tiledb::sm::Query& b_query_internal = *b_query->query_; - const auto& a_stats = *a_query_internal.stats(); - const auto& b_stats = *b_query_internal.stats(); - - stat_keeper.report_metric( - a_key, "loop_num", optional_json(a_stats.find_counter("loop_num"))); - stat_keeper.report_metric( - b_key, "loop_num", optional_json(b_stats.find_counter("loop_num"))); - stat_keeper.report_metric( - a_key, - "internal_loop_num", - optional_json(a_stats.find_counter("internal_loop_num"))); - stat_keeper.report_metric( - b_key, - "internal_loop_num", - optional_json(b_stats.find_counter("internal_loop_num"))); - - // record parallel merge timers - stat_keeper.report_timer( - a_key, - "preprocess_result_tile_order_compute", - optional_json( - a_stats.find_timer("preprocess_result_tile_order_compute.sum"))); - stat_keeper.report_timer( - a_key, - "preprocess_result_tile_order_await", - optional_json( - a_stats.find_timer("preprocess_result_tile_order_await.sum"))); - stat_keeper.report_timer( - b_key, - "preprocess_result_tile_order_compute", - optional_json( - b_stats.find_timer("preprocess_result_tile_order_compute.sum"))); - stat_keeper.report_timer( - b_key, - "preprocess_result_tile_order_await", - optional_json( - b_stats.find_timer("preprocess_result_tile_order_await.sum"))); + for (size_t q = 0; q < queries.size(); q++) { + const tiledb::sm::Query& query_internal = *queries[q].ptr().get()->query_; + const auto& stats = *query_internal.stats(); + + stat_keeper.report_metric( + keys[q], "loop_num", optional_json(stats.find_counter("loop_num"))); + stat_keeper.report_metric( + keys[q], + "internal_loop_num", + optional_json(stats.find_counter("internal_loop_num"))); + + // record parallel merge timers + stat_keeper.report_timer( + keys[q], + "preprocess_result_tile_order_compute", + optional_json( + stats.find_timer("preprocess_result_tile_order_compute.sum"))); + stat_keeper.report_timer( + keys[q], + "preprocess_result_tile_order_await", + optional_json( + stats.find_timer("preprocess_result_tile_order_await.sum"))); + } } // change this to match the schema of the target arrays @@ -631,18 +597,16 @@ using Fragment = Fragment2D; * Reads key-value pairs from a JSON object to construct and return a * `tiledb_config_t`. */ -capi_return_t json2config(tiledb_config_t** config, const json& j) { - tiledb_error_t* error; - RETURN_IF_ERR(tiledb_config_alloc(config, &error)); +tiledb::Config json2config(const json& j) { + std::map params; const json jconf = j["config"]; for (auto it = jconf.begin(); it != jconf.end(); ++it) { const auto key = it.key(); const auto value = nlohmann::to_string(it.value()); - RETURN_IF_ERR( - tiledb_config_set(*config, key.c_str(), value.c_str(), &error)); + params[key] = nlohmann::to_string(it.value()); } - return TILEDB_OK; + return tiledb::Config(params); } int main(int argc, char** argv) { @@ -658,9 +622,17 @@ int main(int argc, char** argv) { std::istreambuf_iterator()); } - tiledb_config_t *a_conf, *b_conf; - RETURN_IF_ERR(json2config(&a_conf, config["a"])); - RETURN_IF_ERR(json2config(&b_conf, config["b"])); + std::vector qconfs; + for (const auto& jsoncfg : config["configurations"]) { + qconfs.push_back(Configuration{ + .name_ = jsoncfg["name"].get(), + .num_user_cells_ = std::nullopt, + .qconf_ = json2config(jsoncfg)}); + if (jsoncfg.find("num_user_cells") != jsoncfg.end()) { + qconfs.back().num_user_cells_.emplace( + jsoncfg["num_user_cells"].get()); + } + } StatKeeper stat_keeper; @@ -668,11 +640,11 @@ int main(int argc, char** argv) { static_cast(&argv[2]), argc - 2); for (const auto& query : config["queries"]) { - QueryConfig qq = QueryConfig::from_json(query); + Query qq = Query::from_json(query); for (const auto& array_uri : array_uris) { try { - run(stat_keeper, array_uri, qq, a_conf, b_conf); + run(stat_keeper, array_uri, qq, qconfs); } catch (const std::exception& e) { std::cerr << "Error on array \"" << array_uri << "\": " << e.what() << std::endl; @@ -682,9 +654,6 @@ int main(int argc, char** argv) { } } - tiledb_config_free(&b_conf); - tiledb_config_free(&a_conf); - std::ofstream out("/tmp/tiledb_submit_a_b.json"); stat_keeper.dump_durations(out); From 0cb5609fff97f31880e40f44d9af0b573f1f61ce Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 30 Jan 2025 14:05:09 -0500 Subject: [PATCH 205/228] Split out RT_ASSERT --- test/support/assert_helpers.h | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/test/support/assert_helpers.h b/test/support/assert_helpers.h index e392f84704e..bf403e8fbd0 100644 --- a/test/support/assert_helpers.h +++ b/test/support/assert_helpers.h @@ -95,11 +95,7 @@ struct AsserterRuntimeException {}; value) { \ RC_ASSERT(__VA_ARGS__); \ } else { \ - if (!(__VA_ARGS__)) { \ - throw std::runtime_error( \ - std::string("Assertion failed: ") + \ - std::string(__STR_VA_(__VA_ARGS__))); \ - } \ + RT_ASSERT(__VA_ARGS__); \ } \ } while (0) @@ -129,4 +125,14 @@ struct AsserterRuntimeException {}; } \ } while (0) +/** Assert which throws a runtime exception upon failure */ +#define RT_ASSERT(...) \ + do { \ + if (!(__VA_ARGS__)) { \ + throw std::runtime_error( \ + std::string("Assertion failed: ") + \ + std::string(__STR_VA_(__VA_ARGS__))); \ + } \ + } while (0) + #endif From c12353072a39b6055fbdaefbcca460d2b31875cb Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 30 Jan 2025 21:43:41 -0500 Subject: [PATCH 206/228] Add unit test for compute_cursor_from_read_state and fix some things --- .../readers/sparse_global_order_reader.cc | 41 +- .../readers/sparse_global_order_reader.h | 101 +++- tiledb/sm/query/readers/test/CMakeLists.txt | 3 +- ...obal_order_reader_preprocess_tile_order.cc | 452 ++++++++++++++++++ 4 files changed, 539 insertions(+), 58 deletions(-) create mode 100644 tiledb/sm/query/readers/test/unit_sparse_global_order_reader_preprocess_tile_order.cc diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 9fbe19445b5..a9695e91bfd 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -296,7 +296,12 @@ Status SparseGlobalOrderReader::dowork() { // iterations are needed. preprocess_future.emplace(*stats_, memory_used_for_coords_total_); preprocess_compute_result_tile_order(preprocess_future.value()); - preprocess_set_cursor_from_read_state(preprocess_future.value()); + preprocess_tile_order_.cursor_ = + PreprocessTileOrder::compute_cursor_from_read_state( + subarray_.relevant_fragments(), + read_state_.frag_idx(), + preprocess_tile_order_.tiles_, + preprocess_future.value()); } else if (preprocess_tile_order_.enabled_) { // NB: we could have avoided loading these in the first place // since we already have determined which tiles qualify, and their order @@ -846,40 +851,6 @@ void SparseGlobalOrderReader::preprocess_compute_result_tile_order( } } -template -void SparseGlobalOrderReader::preprocess_set_cursor_from_read_state( - PreprocessTileMergeFuture& merge_future) { - const auto& state = read_state_.frag_idx(); - const auto& tiles = preprocess_tile_order_.tiles_; - // Find the lower bound cursor whose tile is greater than all of - // the read state tiles. See `create_result_tiles_using_preprocess`. - // If the cursor is nonzero then we will create result tiles - // between the read state and the cursor. - uint64_t bound = 0; - for (size_t f = 0; f < state.size(); f++) { - for (; bound < tiles.size(); bound++) { - if (state[f].tile_idx_ == 0 && state[f].cell_idx_ == 0) { - // initial state (even if tile 0 is filtered by the subarray) - break; - } - - merge_future.wait_for(bound); - - if (tiles[bound].fragment_idx_ != f) { - continue; - } else if (state[f].cell_idx_ == 0) { - if (state[f].tile_idx_ <= tiles[bound].tile_idx_) { - break; - } - } else if (state[f].tile_idx_ < tiles[bound].tile_idx_) { - break; - } - } - } - - preprocess_tile_order_.cursor_ = bound; -} - template std::vector SparseGlobalOrderReader::create_result_tiles( diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.h b/tiledb/sm/query/readers/sparse_global_order_reader.h index 8a1454f0f50..e3d38defdfe 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.h +++ b/tiledb/sm/query/readers/sparse_global_order_reader.h @@ -78,6 +78,85 @@ struct PreprocessTileOrder { bool has_more_tiles() const { return enabled_ && cursor_ < tiles_.size(); } + + /** + * Identifies the current position in the preprocess tile stream using + * the read state, and updates the cursor to that position. + * This is called after starting the result tile order. + * + * When running libtiledb natively, this is only called in the + * first instance of `tiledb_query_submit` and sets the cursor + * to that position. + * + * When running libtiledb against the REST server, this is called + * on the REST server for each `tiledb_query_submit`. + * We assume that recomputing the tile order for each message + * is cheaper than serializing the tile order after computing it once. + * However, as the read state progresses over the subarray, + * the tiles which qualify as input to the tile merge change. + * This causes the tile list to vary from submit to submit. + * Hence instead of serializing the position in the list we must + * recompute it. + */ + template + static uint64_t compute_cursor_from_read_state( + const RelevantFragments& relevant_fragments, + const std::span& read_state, + const std::span& tiles, + MergeFuture& merge_future) { + // The current position is that of the first tile in the list + // which comes after the last tile in the list from which + // data was emitted. + // + // Data was emitted from a tile if its `cell_idx_` is nonzero. + // + // In a synchronous world we can identify that tile trivially by + // walking backwards from the end of the list and finding + // the first nonzero `cell_idx_`. + // + // In an async world we want to walk forwards, so that we + // don't have to wait for the whole merge to finish. + + size_t bound = 0; + for (const auto f : relevant_fragments) { + std::optional f_bound; + for (uint64_t t = 0; t < tiles.size(); t++) { + merge_future.wait_for(t); + + if (tiles[t].fragment_idx_ != f) { + continue; + } + if (tiles[t].tile_idx_ < read_state[f].tile_idx_) { + f_bound.emplace(t + 1); + } else if (tiles[t].tile_idx_ == read_state[f].tile_idx_) { + if (read_state[f].cell_idx_ > 0) { + // this is the current tile, we have emitted some cells already + f_bound.emplace(t + 1); + } else if (f_bound.has_value()) { + // we exhausted the previous tile but did not emit anything from + // this one + } else { + // this is the first tile from the fragment, with no data emitted + } + break; + } else { + // this means we never saw the `==` tile, it did not qualify + // (is this even reachable except for the end of the fragment?) + // but the read state had advanced beyond the previous, so that's the + // bound + if (f_bound.has_value()) { + f_bound.emplace(f_bound.value() + 1); + } + break; + } + } + if (f_bound.has_value() && f_bound.value() > bound) { + bound = f_bound.value(); + } + } + + return bound; + } }; /** Processes sparse global order read queries. */ @@ -296,28 +375,6 @@ class SparseGlobalOrderReader : public SparseIndexReaderBase, void preprocess_compute_result_tile_order( PreprocessTileMergeFuture& merge_future); - /** - * Identifies the current position in the preprocess tile stream using - * the read state, and updates the cursor to that position. - * This is called after starting the result tile order. - * - * When running libtiledb natively, this is only called in the - * first instance of `tiledb_query_submit` and sets the cursor - * to that position. - * - * When running libtiledb against the REST server, this is called - * on the REST server for each `tiledb_query_submit`. - * We assume that recomputing the tile order for each message - * is cheaper than serializing the tile order after computing it once. - * However, as the read state progresses over the subarray, - * the tiles which qualify as input to the tile merge change. - * This causes the tile list to vary from submit to submit. - * Hence instead of serializing the position in the list we must - * recompute it. - */ - void preprocess_set_cursor_from_read_state( - PreprocessTileMergeFuture& merge_future); - /** * Create the result tiles. * diff --git a/tiledb/sm/query/readers/test/CMakeLists.txt b/tiledb/sm/query/readers/test/CMakeLists.txt index 8de0a4fa8c5..8d1b6479db5 100644 --- a/tiledb/sm/query/readers/test/CMakeLists.txt +++ b/tiledb/sm/query/readers/test/CMakeLists.txt @@ -27,6 +27,7 @@ include(unit_test) commence(unit_test readers) - this_target_sources(main.cc unit_reader_base.cc) + this_target_sources(main.cc unit_reader_base.cc unit_sparse_global_order_reader_preprocess_tile_order.cc) this_target_object_libraries(baseline) + this_target_link_libraries(rapidcheck) conclude(unit_test) diff --git a/tiledb/sm/query/readers/test/unit_sparse_global_order_reader_preprocess_tile_order.cc b/tiledb/sm/query/readers/test/unit_sparse_global_order_reader_preprocess_tile_order.cc new file mode 100644 index 00000000000..16d1ab867c6 --- /dev/null +++ b/tiledb/sm/query/readers/test/unit_sparse_global_order_reader_preprocess_tile_order.cc @@ -0,0 +1,452 @@ +/** + * @file unit_sparse_global_order_reader_preprocess_tile_order.cc + * + * @section LICENSE + * + * The MIT License + * + * @copyright Copyright (c) 2025 TileDB, 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. + * + * @section DESCRIPTION + * + * Tests the `SparseGlobalOrderReader` preprocess tile merge functionality. + */ + +#include "tiledb/common/common.h" +#include "tiledb/sm/query/readers/sparse_global_order_reader.h" +#include "tiledb/sm/query/readers/sparse_index_reader_base.h" + +struct VerifySetCursorFromReadState; + +// forward declarations of `showValue` overloads +// (these must be declared prior to including `rapidcheck/Show.hpp` for some +// reason) +namespace rc { +namespace detail { + +void showValue(const tiledb::sm::ResultTileId& rt, std::ostream& os); +void showValue(const tiledb::sm::FragIdx& f, std::ostream& os); +void showValue(const VerifySetCursorFromReadState& instance, std::ostream& os); + +} // namespace detail +} // namespace rc + +#include +#include +#include + +using namespace tiledb::sm; +using tiledb::test::AsserterCatch; +using tiledb::test::AsserterRapidcheck; + +struct NotAsync { + void wait_for(uint64_t) { + // no-op + } + + static NotAsync INSTANCE; +}; + +NotAsync NotAsync::INSTANCE = NotAsync(); + +/* +static bool has_not_started_yet( + const FragIdx& fragment_read_state, uint64_t tile) { + if (fragment_read_state.tile_idx_ == tile) { + return fragment_read_state.cell_idx_ == 0; + } else { + return fragment_read_state.tile_idx_ < tile; + } +} + +static bool has_not_started_yet( + const FragIdx& fragment_read_state, const ResultTileId& tile) { + return has_not_started_yet(fragment_read_state, tile.tile_idx_); +} +*/ + +struct VerifySetCursorFromReadState { + std::map read_state_; + std::vector qualified_tiles_; + + VerifySetCursorFromReadState( + std::map&& read_state, + std::vector&& qualified_tiles) + : read_state_(std::move(read_state)) + , qualified_tiles_(qualified_tiles) { + } + + VerifySetCursorFromReadState( + std::vector&& read_state, + std::vector&& qualified_tiles) + : qualified_tiles_(std::move(qualified_tiles)) { + for (unsigned f = 0; f < read_state.size(); f++) { + if (read_state[f].tile_idx_ != 0 || read_state[f].cell_idx_ != 0) { + read_state_[f].swap(read_state[f]); + } + } + } + + RelevantFragments relevant_fragments() const { + std::set distinct_fragments; + for (const auto& rt : qualified_tiles_) { + distinct_fragments.insert(rt.fragment_idx_); + } + + std::vector relevant_fragments( + distinct_fragments.begin(), distinct_fragments.end()); + return RelevantFragments(relevant_fragments); + } + + /** validate input */ + template + void validate() { + if (qualified_tiles_.empty()) { + ASSERTER(read_state_.empty()); + } + + // each fragment must have its tiles sorted + std::map last_tile; + for (const auto& rt : qualified_tiles_) { + if (last_tile.find(rt.fragment_idx_) != last_tile.end()) { + RC_PRE(last_tile[rt.fragment_idx_] < rt.tile_idx_); + } + last_tile[rt.fragment_idx_] = rt.tile_idx_; + } + + for (const auto& fragment : read_state_) { + const unsigned f = fragment.first; + const auto& frag_idx = fragment.second; + if (last_tile.find(f) != last_tile.end()) { + // read state does not have to be a tile in the list, + // but if it isn't then its cell had better be zero + bool found = frag_idx.cell_idx_ == 0; + for (size_t rti = 0; !found && rti < qualified_tiles_.size(); rti++) { + const auto& rt = qualified_tiles_[rti]; + if (rt.fragment_idx_ == f && rt.tile_idx_ == frag_idx.tile_idx_) { + found = true; + } + } + RC_PRE(found); + } else { + // no read state + RC_PRE(frag_idx.tile_idx_ == 0); + RC_PRE(frag_idx.cell_idx_ == 0); + } + } + } + + template + uint64_t verify() { + validate(); + + std::vector read_state; + if (!qualified_tiles_.empty()) { + read_state.resize( + 1 + std::max_element( + qualified_tiles_.begin(), + qualified_tiles_.end(), + [](const auto& a, const auto& b) { + return a.fragment_idx_ < b.fragment_idx_; + }) + ->fragment_idx_); + } + for (const auto& fragment : read_state_) { + read_state[fragment.first] = std::move( + FragIdx(fragment.second.tile_idx_, fragment.second.cell_idx_)); + } + + const uint64_t cursor = PreprocessTileOrder::compute_cursor_from_read_state( + relevant_fragments(), read_state, qualified_tiles_, NotAsync::INSTANCE); + ASSERTER(cursor <= qualified_tiles_.size()); + + for (uint64_t rti = qualified_tiles_.size(); rti > cursor; rti--) { + const auto& rt = qualified_tiles_[rti - 1]; + const auto& rstate = read_state[rt.fragment_idx_]; + ASSERTER(rstate.tile_idx_ <= rt.tile_idx_); + if (rstate.tile_idx_ == rt.tile_idx_) { + ASSERTER(rstate.cell_idx_ == 0); + } + } + return cursor; + } +}; + +// rapidcheck generators +namespace rc { + +namespace detail { + +void showValue(const ResultTileId& rt, std::ostream& os) { + os << "ResultTileId { .fragment_idx_ = " << rt.fragment_idx_ + << ", .tile_idx_ = " << rt.tile_idx_ << "}" << std::endl; +} + +void showValue(const FragIdx& f, std::ostream& os) { + os << "FragIdx { .tile_idx_ = " << f.tile_idx_ + << ", .cell_idx_ = " << f.cell_idx_ << "}" << std::endl; +} + +void showValue(const VerifySetCursorFromReadState& instance, std::ostream& os) { + os << ".read_state_ = "; + showValue(instance.read_state_, os); + os << ".qualified_tiles_ = "; + showValue(instance.qualified_tiles_, os); +} + +} // namespace detail + +template <> +struct Arbitrary { + static Gen arbitrary() { + return gen::apply( + [](unsigned f, uint64_t t) { return ResultTileId(f, t); }, + gen::inRange(0, 1024), + gen::inRange(0, 1024 * 1024)); + } +}; + +Gen> make_qualified_tiles() { + auto gen_rts = + gen::container>(gen::arbitrary()); + + return gen::map(gen_rts, [](std::vector rts) { + std::vector rts_out(rts.size()); + std::map> fragments; + for (size_t rt = 0; rt < rts.size(); rt++) { + fragments[rts[rt].fragment_idx_].push_back(rt); + } + for (auto& f : fragments) { + const auto idx_unsorted = f.second; + auto idx_sorted = idx_unsorted; + std::sort(idx_sorted.begin(), idx_sorted.end(), [&](size_t a, size_t b) { + return rts[a].tile_idx_ < rts[b].tile_idx_; + }); + + for (size_t fi = 0; fi < idx_sorted.size(); fi++) { + rts_out[idx_unsorted[fi]] = rts[idx_sorted[fi]]; + } + } + return rts_out; + }); +} + +template <> +struct Arbitrary { + static Gen arbitrary() { + auto gen_tiles = make_qualified_tiles(); + + auto gen_read_states = + gen::mapcat(gen_tiles, [](std::vector tiles) { + if (tiles.empty()) { + return gen::pair( + gen::just(tiles), + gen::construct>>()); + } + return gen::pair( + gen::just(tiles), + gen::container>>( + gen::apply( + [](ResultTileId qualified_tile, Maybe cell_idx) + -> std::pair { + if (cell_idx) { + return std::make_pair( + qualified_tile.fragment_idx_, + FragIdx(qualified_tile.tile_idx_, *cell_idx)); + } else { + return std::make_pair( + qualified_tile.fragment_idx_, + FragIdx(qualified_tile.tile_idx_ + 1, 0)); + } + }, + gen::elementOf(tiles), + gen::maybe( + gen::inRange(0, 1024 * 1024 * 128))))); + }); + + return gen::apply( + [](std::pair< + std::vector, + std::vector>> arg) { + std::vector tiles = std::move(arg.first); + std::map read_state; + + for (auto& state : arg.second) { + read_state[state.first].swap(state.second); + } + + return VerifySetCursorFromReadState( + std::move(read_state), std::move(tiles)); + }, + gen_read_states); + } +}; + +} // namespace rc + +TEST_CASE( + "SparseGlobalOrderReader: PreprocessTileMerge: correct cursor " + "computation", + "[sparse-global-order][preprocess-tile-merge]") { + using RT = ResultTileId; + + SECTION("Example") { + std::vector read_state; + read_state.resize(10); + + // partially done fragment + read_state[4] = std::move(FragIdx(7, 32)); + // done, no more tiles in this fragment + read_state[6] = std::move(FragIdx(15, 0)); + // other fragments not started + + std::vector tiles = { + RT(6, 8), + RT(6, 9), + RT(6, 10), + RT(6, 11), + RT(6, 12), + RT(6, 13), + RT(6, 14), + RT(4, 4), + RT(4, 5), + RT(4, 6), + RT(4, 7), + RT(8, 32), + RT(4, 8), + RT(8, 33), + RT(8, 34), + RT(8, 35), + RT(8, 36)}; + + const auto cursor = + VerifySetCursorFromReadState(std::move(read_state), std::move(tiles)) + .verify(); + CHECK(cursor == 11); + } + + SECTION("Shrink", "Some examples found by rapidcheck") { + SECTION("Example 1") { + std::vector read_state; + read_state.emplace_back(0, 1); + + auto tiles = std::vector{ResultTileId(0, 0)}; + + const auto cursor = + VerifySetCursorFromReadState(std::move(read_state), std::move(tiles)) + .verify(); + CHECK(cursor == 1); + } + SECTION("Example 2") { + std::vector read_state; + read_state.emplace_back(0, 1); + read_state.emplace_back(0, 0); + + auto tiles = std::vector{ + ResultTileId(0, 0), ResultTileId(1, 0), ResultTileId(0, 1)}; + + const auto cursor = + VerifySetCursorFromReadState(std::move(read_state), std::move(tiles)) + .verify(); + CHECK(cursor == 1); + } + SECTION("Example 3") { + std::vector read_state; + read_state.emplace_back(0, 0); + read_state.emplace_back(0, 1); + + auto tiles = std::vector{ + ResultTileId(0, 0), + ResultTileId(1, 0), + ResultTileId(0, 1), + ResultTileId(0, 2), + ResultTileId(0, 3)}; + + const auto cursor = + VerifySetCursorFromReadState(std::move(read_state), std::move(tiles)) + .verify(); + CHECK(cursor == 2); + } + SECTION("Example 4") { + std::vector read_state; + read_state.emplace_back(0, 0); + read_state.emplace_back(0, 0); + read_state.emplace_back(0, 0); + + std::vector tiles = { + RT(2, 0), + RT(0, 0), + RT(0, 1), + RT(0, 2), + RT(0, 3), + RT(0, 4), + RT(0, 5), + RT(2, 1)}; + + const auto cursor = + VerifySetCursorFromReadState(std::move(read_state), std::move(tiles)) + .verify(); + CHECK(cursor == 0); + } + SECTION( + "Example 5", "Read state cell_idx=0 can be used as the bound tile") { + std::vector read_state; + read_state.emplace_back(3, 0); + read_state.emplace_back(0, 0); + read_state.emplace_back(0, 0); + + std::vector tiles = { + RT(2, 0), + RT(0, 0), + RT(0, 1), + RT(0, 2), + RT(0, 3), + RT(0, 4), + RT(0, 5), + RT(2, 1)}; + + const auto cursor = + VerifySetCursorFromReadState(std::move(read_state), std::move(tiles)) + .verify(); + CHECK(cursor == 4); + } + SECTION("Example 6") { + std::vector read_state; + read_state.emplace_back(0, 0); + read_state.emplace_back(0, 1); + + std::vector tiles = {RT(0, 0), RT(0, 1), RT(1, 0), RT(0, 2)}; + + const auto cursor = + VerifySetCursorFromReadState(std::move(read_state), std::move(tiles)) + .verify(); + CHECK(cursor == 3); + } + } + + SECTION("Rapidcheck") { + rc::prop( + "verify_set_cursor_from_read_state", + [](VerifySetCursorFromReadState input) { + input.verify(); + }); + } +} From d9fa09481832d7d5e815e17dbacc1aedfc674734 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 30 Jan 2025 21:44:18 -0500 Subject: [PATCH 207/228] tiledb_submit_a_b tighter control over the domain --- test/performance/tiledb_submit_a_b.cc | 73 ++++++++++++++++++--------- 1 file changed, 50 insertions(+), 23 deletions(-) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 693ee31a4e0..2ce0d691ce8 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -74,7 +74,12 @@ * "layout": "global_order", * "subarray": [ * { - * "%": 30 + * "start": { + * "%": 30 + * }, + * "end": { + * "%": 50 + * } * } * ] * } @@ -223,26 +228,49 @@ struct StatKeeper { } }; -void shrink_domain( - tiledb::Array& array, - unsigned dim, - tiledb::Subarray& subarray, - int percent) { - // FIXME: make generic - int64_t domain[2]; - std::tie(domain[0], domain[1]) = array.non_empty_domain(dim); +struct SubarrayDimension { + std::optional start_percent_; + std::optional end_percent_; - const auto span = (domain[1] - domain[0] + 1); - domain[0] += ((span * (100 - percent)) / 100) / 2; - domain[1] -= ((span * (100 - percent)) / 100) / 2; + static SubarrayDimension from_json(const json& jdim) { + SubarrayDimension dim; + if (jdim.find("start") != jdim.end()) { + dim.start_percent_.emplace(jdim["start"]["%"].get()); + } + if (jdim.find("end") != jdim.end()) { + dim.end_percent_.emplace(jdim["end"]["%"].get()); + } + return dim; + } - subarray.add_range(dim, domain[0], domain[1]); -} + void apply( + tiledb::Array& array, unsigned dim, tiledb::Subarray& subarray) const { + // FIXME: make generic domain type + int64_t non_empty_domain[2], subarray_domain[2]; + std::tie(non_empty_domain[0], non_empty_domain[1]) = + array.non_empty_domain(dim); + + subarray_domain[0] = non_empty_domain[0]; + subarray_domain[1] = non_empty_domain[1]; + + const auto span = (non_empty_domain[1] - non_empty_domain[0] + 1); + if (start_percent_.has_value()) { + subarray_domain[0] = + non_empty_domain[0] + (span * start_percent_.value()) / 100; + } + if (end_percent_.has_value()) { + subarray_domain[1] = + non_empty_domain[0] + ((span * end_percent_.value()) / 100); + } + + subarray.add_range(dim, subarray_domain[0], subarray_domain[1]); + } +}; struct Query { std::string label_; tiledb_layout_t layout_; - std::vector> subarray_percent_; + std::vector> subarray_; static Query from_json(const json& jq) { Query q; @@ -271,11 +299,10 @@ struct Query { if (jq.find("subarray") != jq.end()) { const auto& jsub = jq["subarray"]; for (const auto& jdim : jsub) { - if (jdim.find("%") != jdim.end()) { - const int percent = jdim["%"].get(); - q.subarray_percent_.push_back(percent); + if (jdim.is_null()) { + q.subarray_.push_back(std::nullopt); } else { - q.subarray_percent_.push_back(std::nullopt); + q.subarray_.push_back(SubarrayDimension::from_json(jdim)); } } } @@ -289,14 +316,14 @@ struct Query { tiledb::Context& ctx, tiledb::Array& array, tiledb::Query& query) const { query.set_layout(layout_); - if (!subarray_percent_.empty()) { + if (!subarray_.empty()) { tiledb::Subarray subarray(ctx, array); tiledb::ArraySchema schema = array.schema(); - for (unsigned d = 0; d < subarray_percent_.size(); d++) { - if (subarray_percent_[d].has_value()) { - shrink_domain(array, d, subarray, subarray_percent_[d].value()); + for (unsigned d = 0; d < subarray_.size(); d++) { + if (subarray_[d].has_value()) { + subarray_[d].value().apply(array, d, subarray); } } From 340a067b7d834cce5118d8b62f7a196e85dcc9d0 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 31 Jan 2025 08:34:27 -0500 Subject: [PATCH 208/228] FragIdx is just POD --- .../query/readers/sparse_index_reader_base.h | 33 ------------------- ...obal_order_reader_preprocess_tile_order.cc | 33 +++++-------------- 2 files changed, 8 insertions(+), 58 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_index_reader_base.h b/tiledb/sm/query/readers/sparse_index_reader_base.h index 2a7553a70ed..b3ee49071c3 100644 --- a/tiledb/sm/query/readers/sparse_index_reader_base.h +++ b/tiledb/sm/query/readers/sparse_index_reader_base.h @@ -53,9 +53,6 @@ class Subarray; */ class FragIdx { public: - /* ********************************* */ - /* CONSTRUCTORS & DESTRUCTORS */ - /* ********************************* */ FragIdx() = default; FragIdx(uint64_t tile_idx, uint64_t cell_idx) @@ -63,36 +60,6 @@ class FragIdx { , cell_idx_(cell_idx) { } - /** Move constructor. */ - FragIdx(FragIdx&& other) noexcept { - // Swap with the argument - swap(other); - } - - /** Move-assign operator. */ - FragIdx& operator=(FragIdx&& other) { - // Swap with the argument - swap(other); - - return *this; - } - - DISABLE_COPY_AND_COPY_ASSIGN(FragIdx); - - /* ********************************* */ - /* PUBLIC METHODS */ - /* ********************************* */ - - /** Swaps the contents (all field values) of this tile with the given tile. */ - void swap(FragIdx& frag_tile_idx) { - std::swap(tile_idx_, frag_tile_idx.tile_idx_); - std::swap(cell_idx_, frag_tile_idx.cell_idx_); - } - - /* ********************************* */ - /* PUBLIC ATTRIBUTES */ - /* ********************************* */ - /** Tile index. */ uint64_t tile_idx_; diff --git a/tiledb/sm/query/readers/test/unit_sparse_global_order_reader_preprocess_tile_order.cc b/tiledb/sm/query/readers/test/unit_sparse_global_order_reader_preprocess_tile_order.cc index 16d1ab867c6..41d619d96d1 100644 --- a/tiledb/sm/query/readers/test/unit_sparse_global_order_reader_preprocess_tile_order.cc +++ b/tiledb/sm/query/readers/test/unit_sparse_global_order_reader_preprocess_tile_order.cc @@ -67,30 +67,14 @@ struct NotAsync { NotAsync NotAsync::INSTANCE = NotAsync(); -/* -static bool has_not_started_yet( - const FragIdx& fragment_read_state, uint64_t tile) { - if (fragment_read_state.tile_idx_ == tile) { - return fragment_read_state.cell_idx_ == 0; - } else { - return fragment_read_state.tile_idx_ < tile; - } -} - -static bool has_not_started_yet( - const FragIdx& fragment_read_state, const ResultTileId& tile) { - return has_not_started_yet(fragment_read_state, tile.tile_idx_); -} -*/ - struct VerifySetCursorFromReadState { std::map read_state_; std::vector qualified_tiles_; VerifySetCursorFromReadState( - std::map&& read_state, - std::vector&& qualified_tiles) - : read_state_(std::move(read_state)) + std::map read_state, + std::vector qualified_tiles) + : read_state_(read_state) , qualified_tiles_(qualified_tiles) { } @@ -100,7 +84,7 @@ struct VerifySetCursorFromReadState { : qualified_tiles_(std::move(qualified_tiles)) { for (unsigned f = 0; f < read_state.size(); f++) { if (read_state[f].tile_idx_ != 0 || read_state[f].cell_idx_ != 0) { - read_state_[f].swap(read_state[f]); + read_state_[f] = read_state[f]; } } } @@ -170,8 +154,8 @@ struct VerifySetCursorFromReadState { ->fragment_idx_); } for (const auto& fragment : read_state_) { - read_state[fragment.first] = std::move( - FragIdx(fragment.second.tile_idx_, fragment.second.cell_idx_)); + read_state[fragment.first] = + FragIdx(fragment.second.tile_idx_, fragment.second.cell_idx_); } const uint64_t cursor = PreprocessTileOrder::compute_cursor_from_read_state( @@ -290,11 +274,10 @@ struct Arbitrary { std::map read_state; for (auto& state : arg.second) { - read_state[state.first].swap(state.second); + read_state[state.first] = state.second; } - return VerifySetCursorFromReadState( - std::move(read_state), std::move(tiles)); + return VerifySetCursorFromReadState(read_state, tiles); }, gen_read_states); } From b23205bf28bbd2b8350f35fdacc38c400638ce6f Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 31 Jan 2025 10:50:54 -0500 Subject: [PATCH 209/228] Easy getter for StatKeeper --- test/performance/tiledb_submit_a_b.cc | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index 2ce0d691ce8..a1d053456e0 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -167,6 +167,10 @@ struct StatKeeper { std::map>> statistics; + StatValue& get(const StatKey& stat) { + return statistics[stat.uri_][stat.qlabel_][stat.configname_]; + } + Timer start_timer(const StatKey& stat) { return tiledb::sm::stats::DurationInstrument( *this, stat); @@ -174,20 +178,17 @@ struct StatKeeper { void report_duration( const StatKey& stat, const std::chrono::duration duration) { - auto& stats = statistics[stat.uri_][stat.qlabel_][stat.configname_]; - stats.durations.push_back(duration.count()); + get(stat).durations.push_back(duration.count()); } void report_metric( const StatKey& stat, const std::string& name, const json& value) { - auto& stats = statistics[stat.uri_][stat.qlabel_][stat.configname_]; - stats.metrics[name] = value; + get(stat).metrics[name] = value; } void report_timer( const StatKey& stat, const std::string& name, const json& value) { - auto& stats = statistics[stat.uri_][stat.qlabel_][stat.configname_]; - stats.metrics[name] = value; + get(stat).metrics[name] = value; } /** From 6fa51ba713f6c083f0e0d9fee25288d3e6826ab4 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 31 Jan 2025 10:54:06 -0500 Subject: [PATCH 210/228] Block on merge and try again if insufficient memory to re-create tiles --- .../query/readers/sparse_global_order_reader.cc | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index a9695e91bfd..1f51637221e 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -1071,8 +1071,20 @@ void SparseGlobalOrderReader::create_result_tiles_using_preprocess( // this is a tile which qualified for the subarray and was // a created result tile, we must continue processing it - const auto budget_exceeded = add_result_tile( - num_dims, f, rt.tile_idx_, *fragment_metadata_[f], result_tiles); + bool budget_exceeded; + while ((budget_exceeded = add_result_tile( + num_dims, + f, + rt.tile_idx_, + *fragment_metadata_[f], + result_tiles)) && + merge_future.has_value()) { + // try to free some memory by waiting for merge if it is ongoing + if (merge_future.has_value()) { + merge_future->block(); + merge_future.reset(); + } + } // all these tiles were created in a previous iteration, so we *had* // the memory budget - and must not any more. Can a user change From 353cd78e01f391ede1b0e7a8cf08a998ad9d7f95 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Fri, 31 Jan 2025 14:09:11 -0500 Subject: [PATCH 211/228] Update set cursor tests to use FragIdx copy constructor, std::map --- ...obal_order_reader_preprocess_tile_order.cc | 89 ++++++++----------- 1 file changed, 35 insertions(+), 54 deletions(-) diff --git a/tiledb/sm/query/readers/test/unit_sparse_global_order_reader_preprocess_tile_order.cc b/tiledb/sm/query/readers/test/unit_sparse_global_order_reader_preprocess_tile_order.cc index 41d619d96d1..a876c00b28b 100644 --- a/tiledb/sm/query/readers/test/unit_sparse_global_order_reader_preprocess_tile_order.cc +++ b/tiledb/sm/query/readers/test/unit_sparse_global_order_reader_preprocess_tile_order.cc @@ -78,17 +78,6 @@ struct VerifySetCursorFromReadState { , qualified_tiles_(qualified_tiles) { } - VerifySetCursorFromReadState( - std::vector&& read_state, - std::vector&& qualified_tiles) - : qualified_tiles_(std::move(qualified_tiles)) { - for (unsigned f = 0; f < read_state.size(); f++) { - if (read_state[f].tile_idx_ != 0 || read_state[f].cell_idx_ != 0) { - read_state_[f] = read_state[f]; - } - } - } - RelevantFragments relevant_fragments() const { std::set distinct_fragments; for (const auto& rt : qualified_tiles_) { @@ -292,13 +281,12 @@ TEST_CASE( using RT = ResultTileId; SECTION("Example") { - std::vector read_state; - read_state.resize(10); + std::map read_state; // partially done fragment - read_state[4] = std::move(FragIdx(7, 32)); + read_state[4] = FragIdx(7, 32); // done, no more tiles in this fragment - read_state[6] = std::move(FragIdx(15, 0)); + read_state[6] = FragIdx(15, 0); // other fragments not started std::vector tiles = { @@ -321,40 +309,37 @@ TEST_CASE( RT(8, 36)}; const auto cursor = - VerifySetCursorFromReadState(std::move(read_state), std::move(tiles)) - .verify(); + VerifySetCursorFromReadState(read_state, tiles).verify(); CHECK(cursor == 11); } SECTION("Shrink", "Some examples found by rapidcheck") { SECTION("Example 1") { - std::vector read_state; - read_state.emplace_back(0, 1); + std::map read_state; + read_state[0] = FragIdx(0, 1); auto tiles = std::vector{ResultTileId(0, 0)}; - const auto cursor = - VerifySetCursorFromReadState(std::move(read_state), std::move(tiles)) - .verify(); + const auto cursor = VerifySetCursorFromReadState(read_state, tiles) + .verify(); CHECK(cursor == 1); } SECTION("Example 2") { - std::vector read_state; - read_state.emplace_back(0, 1); - read_state.emplace_back(0, 0); + std::map read_state; + read_state[0] = FragIdx(0, 1); + read_state[1] = FragIdx(0, 0); auto tiles = std::vector{ ResultTileId(0, 0), ResultTileId(1, 0), ResultTileId(0, 1)}; - const auto cursor = - VerifySetCursorFromReadState(std::move(read_state), std::move(tiles)) - .verify(); + const auto cursor = VerifySetCursorFromReadState(read_state, tiles) + .verify(); CHECK(cursor == 1); } SECTION("Example 3") { - std::vector read_state; - read_state.emplace_back(0, 0); - read_state.emplace_back(0, 1); + std::map read_state; + read_state[0] = FragIdx(0, 0); + read_state[1] = FragIdx(0, 1); auto tiles = std::vector{ ResultTileId(0, 0), @@ -363,16 +348,15 @@ TEST_CASE( ResultTileId(0, 2), ResultTileId(0, 3)}; - const auto cursor = - VerifySetCursorFromReadState(std::move(read_state), std::move(tiles)) - .verify(); + const auto cursor = VerifySetCursorFromReadState(read_state, tiles) + .verify(); CHECK(cursor == 2); } SECTION("Example 4") { - std::vector read_state; - read_state.emplace_back(0, 0); - read_state.emplace_back(0, 0); - read_state.emplace_back(0, 0); + std::map read_state; + read_state[0] = FragIdx(0, 0); + read_state[1] = FragIdx(0, 0); + read_state[2] = FragIdx(0, 0); std::vector tiles = { RT(2, 0), @@ -384,17 +368,16 @@ TEST_CASE( RT(0, 5), RT(2, 1)}; - const auto cursor = - VerifySetCursorFromReadState(std::move(read_state), std::move(tiles)) - .verify(); + const auto cursor = VerifySetCursorFromReadState(read_state, tiles) + .verify(); CHECK(cursor == 0); } SECTION( "Example 5", "Read state cell_idx=0 can be used as the bound tile") { - std::vector read_state; - read_state.emplace_back(3, 0); - read_state.emplace_back(0, 0); - read_state.emplace_back(0, 0); + std::map read_state; + read_state[0] = FragIdx(3, 0); + read_state[1] = FragIdx(0, 0); + read_state[2] = FragIdx(0, 0); std::vector tiles = { RT(2, 0), @@ -406,21 +389,19 @@ TEST_CASE( RT(0, 5), RT(2, 1)}; - const auto cursor = - VerifySetCursorFromReadState(std::move(read_state), std::move(tiles)) - .verify(); + const auto cursor = VerifySetCursorFromReadState(read_state, tiles) + .verify(); CHECK(cursor == 4); } SECTION("Example 6") { - std::vector read_state; - read_state.emplace_back(0, 0); - read_state.emplace_back(0, 1); + std::map read_state; + read_state[0] = FragIdx(0, 0); + read_state[1] = FragIdx(0, 1); std::vector tiles = {RT(0, 0), RT(0, 1), RT(1, 0), RT(0, 2)}; - const auto cursor = - VerifySetCursorFromReadState(std::move(read_state), std::move(tiles)) - .verify(); + const auto cursor = VerifySetCursorFromReadState(read_state, tiles) + .verify(); CHECK(cursor == 3); } } From 87c659ba1fb3f6265ff05df2caa842cbb9228a0c Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Tue, 4 Feb 2025 11:15:28 -0500 Subject: [PATCH 212/228] tiledb_submit_a_b does memory budget --- test/performance/tiledb_submit_a_b.cc | 52 ++++++++++++++++++--------- 1 file changed, 36 insertions(+), 16 deletions(-) diff --git a/test/performance/tiledb_submit_a_b.cc b/test/performance/tiledb_submit_a_b.cc index a1d053456e0..d485a36b69e 100644 --- a/test/performance/tiledb_submit_a_b.cc +++ b/test/performance/tiledb_submit_a_b.cc @@ -57,6 +57,9 @@ * { * "name": "a", * "num_user_cells": 16777216, + * "memory_budget": { + * "total": "1073741824" + * }, * "config": { * "sm.query.sparse_global_order.preprocess_tile_merge": 0 * } @@ -64,6 +67,9 @@ * { * "name": "b", * "num_user_cells: 16777216 + * "memory_budget": { + * "total": "1073741824" + * }, * "config": { * "sm.query.sparse_global_order.preprocess_tile_merge": 128 * } @@ -89,8 +95,12 @@ * * The "config" field of each configuration object is a set of key-value * pairs which are set on a `tileb::Config` object for instances - * of each query. The "name" field identifies the configuration; - * and the "num_user_cells" field sets the size of the user buffer. + * of each query. + * - The "name" field identifies the configuration. + * - The "num_user_cells" field sets the size of the user buffer. + * - The "memory_budget" field sets the query memory budget. + * - The "config" field is a list of key-value pairs which are + * passed to the query configuration options. * * Each item in "queries" specifies a query to run the comparison for. * @@ -144,6 +154,21 @@ struct Configuration { std::string name_; std::optional num_user_cells_; tiledb::Config qconf_; + + tiledb::test::SparseGlobalOrderReaderMemoryBudget memory_; + + Configuration() { + memory_.total_budget_ = std::to_string(1024 * 1024 * 1024); + memory_.ratio_tile_ranges_ = "0.01"; + } + + void memory_budget_from_json(const json& jmem) { + if (jmem.find("total") != jmem.end()) { + memory_.total_budget_ = jmem["total"].get(); + } + // TODO: other fields as needed + memory_.apply(qconf_.ptr().get()); + } }; /** @@ -433,10 +458,6 @@ static void run( const char* array_uri, const Query& query_config, const std::span configs) { - tiledb::test::SparseGlobalOrderReaderMemoryBudget memory; - memory.total_budget_ = std::to_string(1024 * 1024 * 1024); - memory.ratio_tile_ranges_ = "0.01"; - std::vector num_user_cells; for (const auto& config : configs) { num_user_cells.push_back( @@ -454,10 +475,7 @@ static void run( reset(q); } - tiledb::Config memconfig; - memory.apply(memconfig.ptr().get()); - - tiledb::Context ctx(memconfig); + tiledb::Context ctx; // Open array for reading. tiledb::Array array(ctx, array_uri, TILEDB_READ); @@ -652,14 +670,16 @@ int main(int argc, char** argv) { std::vector qconfs; for (const auto& jsoncfg : config["configurations"]) { - qconfs.push_back(Configuration{ - .name_ = jsoncfg["name"].get(), - .num_user_cells_ = std::nullopt, - .qconf_ = json2config(jsoncfg)}); + Configuration cfg; + cfg.name_ = jsoncfg["name"].get(); + cfg.qconf_ = json2config(jsoncfg); if (jsoncfg.find("num_user_cells") != jsoncfg.end()) { - qconfs.back().num_user_cells_.emplace( - jsoncfg["num_user_cells"].get()); + cfg.num_user_cells_.emplace(jsoncfg["num_user_cells"].get()); + } + if (jsoncfg.find("memory_budget") != jsoncfg.end()) { + cfg.memory_budget_from_json(jsoncfg["memory_budget"]); } + qconfs.push_back(cfg); } StatKeeper stat_keeper; From 69dafd773da9c6169b03847fcee9afb287584622 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 5 Feb 2025 16:39:15 -0500 Subject: [PATCH 213/228] Update rapidcheck/REST tags --- test/src/unit-sparse-global-order-reader.cc | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 4f366c81257..1d3e13e638d 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -1252,7 +1252,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: fragment skew", - "[sparse-global-order][rest]") { + "[sparse-global-order][rest][rapidcheck]") { auto doit = [this]( size_t fragment_size, size_t num_user_cells, @@ -1338,7 +1338,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: fragment interleave", - "[sparse-global-order][rest]") { + "[sparse-global-order][rest][rapidcheck]") { // NB: the tile extent is 2 auto doit = [this]( size_t fragment_size, @@ -1428,7 +1428,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: fragment wide overlap", - "[sparse-global-order][rest]") { + "[sparse-global-order][rest][rapidcheck]") { auto doit = [this]( size_t num_fragments, size_t fragment_size, @@ -1533,7 +1533,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: out-of-order MBRs", - "[sparse-global-order][rest]") { + "[sparse-global-order][rest][rapidcheck]") { auto doit = [this]( tiledb_layout_t tile_order, tiledb_layout_t cell_order, @@ -1684,7 +1684,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: fragment skew 2d merge bound", - "[sparse-global-order]") { + "[sparse-global-order][rest][rapidcheck]") { auto doit = [this]( tiledb_layout_t tile_order, tiledb_layout_t cell_order, @@ -3244,7 +3244,7 @@ void show(const FxRun2D& instance, std::ostream& os) { TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: rapidcheck 1d", - "[sparse-global-order][rapidcheck]") { + "[sparse-global-order][rest][rapidcheck]") { SECTION("Rapidcheck") { rc::prop( "rapidcheck arbitrary 1d", [this](rc::NonShrinking instance) { @@ -3266,7 +3266,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( CSparseGlobalOrderFx, "Sparse global order reader: rapidcheck 2d", - "[sparse-global-order][rapidcheck]") { + "[sparse-global-order][rest][rapidcheck]") { SECTION("rapidcheck") { rc::prop( "rapidcheck arbitrary 2d", [this](rc::NonShrinking instance) { From 6761a124224c37b77cad7a6861b079808df8dc8d Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Wed, 5 Feb 2025 16:43:50 -0500 Subject: [PATCH 214/228] CI branch testing --- .gitlab-ci.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 294109c1b26..e9fb54cce78 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -18,4 +18,5 @@ trigger_pipeline: TILEDB_REF: ${CI_COMMIT_REF_NAME} trigger: project: tiledb-inc/tiledb-internal - strategy: depend + strategy: depend + branch: rr/sc-60366-separate-rapidcheck-job From f4a80356fb02babebd391c138a112cae5f4dbb14 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 6 Feb 2025 07:59:01 -0500 Subject: [PATCH 215/228] Remove gitlab branch now that #40 is merged --- .gitlab-ci.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index e9fb54cce78..95f81b57bed 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -19,4 +19,3 @@ trigger_pipeline: trigger: project: tiledb-inc/tiledb-internal strategy: depend - branch: rr/sc-60366-separate-rapidcheck-job From 7a6d87cfad409f22926e46409f74346ca74287ce Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 6 Feb 2025 08:02:33 -0500 Subject: [PATCH 216/228] Add experimental note to configs --- tiledb/api/c_api/config/config_api_external.h | 1 + tiledb/sm/cpp_api/config.h | 1 + 2 files changed, 2 insertions(+) diff --git a/tiledb/api/c_api/config/config_api_external.h b/tiledb/api/c_api/config/config_api_external.h index 15ab34ecc5e..212e16906fe 100644 --- a/tiledb/api/c_api/config/config_api_external.h +++ b/tiledb/api/c_api/config/config_api_external.h @@ -258,6 +258,7 @@ TILEDB_EXPORT void tiledb_config_free(tiledb_config_t** config) TILEDB_NOEXCEPT; * or "legacy".
* **Default**: refactored * - `sm.query.sparse_global_order.preprocess_tile_merge`
+ * **Experimental for testing purposes, do not use.**
* Performance configuration for sparse global order read queries. * If nonzero, prior to loading the first tiles, the reader will run * a preprocessing step to arrange tiles from all fragments in a single diff --git a/tiledb/sm/cpp_api/config.h b/tiledb/sm/cpp_api/config.h index ec9effe0621..e9e7ab64a48 100644 --- a/tiledb/sm/cpp_api/config.h +++ b/tiledb/sm/cpp_api/config.h @@ -428,6 +428,7 @@ class Config { * or "legacy".
* **Default**: refactored * - `sm.query.sparse_global_order.preprocess_tile_merge`
+ * **Experimental for testing purposes, do not use.**
* Performance configuration for sparse global order read queries. * If nonzero, prior to loading the first tiles, the reader will run * a preprocessing step to arrange tiles from all fragments in a single From adb8f1d2efb14b766a511781b635a9b5271896cd Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 6 Feb 2025 08:24:34 -0500 Subject: [PATCH 217/228] add_next_cell_to_queue needs lock to safely to_delete.push_back --- tiledb/sm/query/readers/sparse_global_order_reader.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index 1f51637221e..cb40f455097 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -1484,6 +1484,8 @@ AddNextCellResult SparseGlobalOrderReader::add_next_cell_to_queue( // Remove the tile from result tiles if it wasn't used at all. if (!rc.tile_->used()) { tmp_read_state_.add_ignored_tile(*to_delete_it); + + std::unique_lock ul(tile_queue_mutex_); to_delete.push_back(to_delete_it); } From 03c540b125865da5836ddacfb036b28aedbf8b97 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 6 Feb 2025 10:50:45 -0500 Subject: [PATCH 218/228] Remove unused capnp ResultTileId --- tiledb/sm/serialization/tiledb-rest.capnp | 10 -- tiledb/sm/serialization/tiledb-rest.capnp.c++ | 71 --------- tiledb/sm/serialization/tiledb-rest.capnp.h | 143 ------------------ 3 files changed, 224 deletions(-) diff --git a/tiledb/sm/serialization/tiledb-rest.capnp b/tiledb/sm/serialization/tiledb-rest.capnp index 0b008b3f18a..b3661f9b7c1 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp +++ b/tiledb/sm/serialization/tiledb-rest.capnp @@ -670,16 +670,6 @@ struct Delete { # Stats object } -struct ResultTileId { -# Identifies a tile - - fragIdx @0 :UInt32; - # Fragment index - - tileIdx @1 :UInt64; - # Tile index -} - struct ResultCellSlab { # Result cell slab diff --git a/tiledb/sm/serialization/tiledb-rest.capnp.c++ b/tiledb/sm/serialization/tiledb-rest.capnp.c++ index 772f63b4d3e..21b54dff743 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp.c++ +++ b/tiledb/sm/serialization/tiledb-rest.capnp.c++ @@ -5222,65 +5222,6 @@ const ::capnp::_::RawSchema s_d74f5fed155d316c = { 2, 2, i_d74f5fed155d316c, nullptr, nullptr, { &s_d74f5fed155d316c, nullptr, nullptr, 0, 0, nullptr }, false }; #endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<48> b_afcbef694e73edb8 = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 184, 237, 115, 78, 105, 239, 203, 175, - 18, 0, 0, 0, 1, 0, 2, 0, - 127, 216, 135, 181, 36, 146, 125, 181, - 0, 0, 7, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 21, 0, 0, 0, 250, 0, 0, 0, - 33, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 29, 0, 0, 0, 119, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 116, 105, 108, 101, 100, 98, 45, 114, - 101, 115, 116, 46, 99, 97, 112, 110, - 112, 58, 82, 101, 115, 117, 108, 116, - 84, 105, 108, 101, 73, 100, 0, 0, - 0, 0, 0, 0, 1, 0, 1, 0, - 8, 0, 0, 0, 3, 0, 4, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 41, 0, 0, 0, 66, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 36, 0, 0, 0, 3, 0, 1, 0, - 48, 0, 0, 0, 2, 0, 1, 0, - 1, 0, 0, 0, 1, 0, 0, 0, - 0, 0, 1, 0, 1, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 45, 0, 0, 0, 66, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 40, 0, 0, 0, 3, 0, 1, 0, - 52, 0, 0, 0, 2, 0, 1, 0, - 102, 114, 97, 103, 73, 100, 120, 0, - 8, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 8, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 116, 105, 108, 101, 73, 100, 120, 0, - 9, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 9, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, } -}; -::capnp::word const* const bp_afcbef694e73edb8 = b_afcbef694e73edb8.words; -#if !CAPNP_LITE -static const uint16_t m_afcbef694e73edb8[] = {0, 1}; -static const uint16_t i_afcbef694e73edb8[] = {0, 1}; -const ::capnp::_::RawSchema s_afcbef694e73edb8 = { - 0xafcbef694e73edb8, b_afcbef694e73edb8.words, 48, nullptr, m_afcbef694e73edb8, - 0, 2, i_afcbef694e73edb8, nullptr, nullptr, { &s_afcbef694e73edb8, nullptr, nullptr, 0, 0, nullptr }, false -}; -#endif // !CAPNP_LITE static const ::capnp::_::AlignedData<79> b_def87cead82188e7 = { { 0, 0, 0, 0, 5, 0, 6, 0, 231, 136, 33, 216, 234, 124, 248, 222, @@ -11401,18 +11342,6 @@ constexpr ::capnp::_::RawSchema const* Delete::_capnpPrivate::schema; #endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL #endif // !CAPNP_LITE -// ResultTileId -#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL -constexpr uint16_t ResultTileId::_capnpPrivate::dataWordSize; -constexpr uint16_t ResultTileId::_capnpPrivate::pointerCount; -#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL -#if !CAPNP_LITE -#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL -constexpr ::capnp::Kind ResultTileId::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* ResultTileId::_capnpPrivate::schema; -#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL -#endif // !CAPNP_LITE - // ResultCellSlab #if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL constexpr uint16_t ResultCellSlab::_capnpPrivate::dataWordSize; diff --git a/tiledb/sm/serialization/tiledb-rest.capnp.h b/tiledb/sm/serialization/tiledb-rest.capnp.h index d11731e784e..1e12ed98719 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp.h +++ b/tiledb/sm/serialization/tiledb-rest.capnp.h @@ -66,7 +66,6 @@ CAPNP_DECLARE_SCHEMA(afc739d5c01e6496); CAPNP_DECLARE_SCHEMA(eaf57cb9871fc06f); CAPNP_DECLARE_SCHEMA(e19754f813ccf79c); CAPNP_DECLARE_SCHEMA(d74f5fed155d316c); -CAPNP_DECLARE_SCHEMA(afcbef694e73edb8); CAPNP_DECLARE_SCHEMA(def87cead82188e7); CAPNP_DECLARE_SCHEMA(c1a2d010de779de5); CAPNP_DECLARE_SCHEMA(c86c77b5f6a2bf0f); @@ -982,23 +981,6 @@ struct Delete { }; }; -struct ResultTileId { - ResultTileId() = delete; - - class Reader; - class Builder; - class Pipeline; - - struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(afcbef694e73edb8, 2, 0) -#if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { - return &schema->defaultBrand; - } -#endif // !CAPNP_LITE - }; -}; - struct ResultCellSlab { ResultCellSlab() = delete; @@ -8862,103 +8844,6 @@ class Delete::Pipeline { }; #endif // !CAPNP_LITE -class ResultTileId::Reader { - public: - typedef ResultTileId Reads; - - Reader() = default; - inline explicit Reader(::capnp::_::StructReader base) - : _reader(base) { - } - - inline ::capnp::MessageSize totalSize() const { - return _reader.totalSize().asPublic(); - } - -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); - } -#endif // !CAPNP_LITE - - inline ::uint32_t getFragIdx() const; - - inline ::uint64_t getTileIdx() const; - - private: - ::capnp::_::StructReader _reader; - template - friend struct ::capnp::ToDynamic_; - template - friend struct ::capnp::_::PointerHelpers; - template - friend struct ::capnp::List; - friend class ::capnp::MessageBuilder; - friend class ::capnp::Orphanage; -}; - -class ResultTileId::Builder { - public: - typedef ResultTileId Builds; - - Builder() = delete; // Deleted to discourage incorrect usage. - // You can explicitly initialize to nullptr instead. - inline Builder(decltype(nullptr)) { - } - inline explicit Builder(::capnp::_::StructBuilder base) - : _builder(base) { - } - inline operator Reader() const { - return Reader(_builder.asReader()); - } - inline Reader asReader() const { - return *this; - } - - inline ::capnp::MessageSize totalSize() const { - return asReader().totalSize(); - } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return asReader().toString(); - } -#endif // !CAPNP_LITE - - inline ::uint32_t getFragIdx(); - inline void setFragIdx(::uint32_t value); - - inline ::uint64_t getTileIdx(); - inline void setTileIdx(::uint64_t value); - - private: - ::capnp::_::StructBuilder _builder; - template - friend struct ::capnp::ToDynamic_; - friend class ::capnp::Orphanage; - template - friend struct ::capnp::_::PointerHelpers; -}; - -#if !CAPNP_LITE -class ResultTileId::Pipeline { - public: - typedef ResultTileId Pipelines; - - inline Pipeline(decltype(nullptr)) - : _typeless(nullptr) { - } - inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) { - } - - private: - ::capnp::AnyPointer::Pipeline _typeless; - friend class ::capnp::PipelineHook; - template - friend struct ::capnp::ToDynamic_; -}; -#endif // !CAPNP_LITE - class ResultCellSlab::Reader { public: typedef ResultCellSlab Reads; @@ -25784,34 +25669,6 @@ Delete::Builder::disownStats() { _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); } -inline ::uint32_t ResultTileId::Reader::getFragIdx() const { - return _reader.getDataField<::uint32_t>( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); -} - -inline ::uint32_t ResultTileId::Builder::getFragIdx() { - return _builder.getDataField<::uint32_t>( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); -} -inline void ResultTileId::Builder::setFragIdx(::uint32_t value) { - _builder.setDataField<::uint32_t>( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); -} - -inline ::uint64_t ResultTileId::Reader::getTileIdx() const { - return _reader.getDataField<::uint64_t>( - ::capnp::bounded<1>() * ::capnp::ELEMENTS); -} - -inline ::uint64_t ResultTileId::Builder::getTileIdx() { - return _builder.getDataField<::uint64_t>( - ::capnp::bounded<1>() * ::capnp::ELEMENTS); -} -inline void ResultTileId::Builder::setTileIdx(::uint64_t value) { - _builder.setDataField<::uint64_t>( - ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); -} - inline ::uint32_t ResultCellSlab::Reader::getFragIdx() const { return _reader.getDataField<::uint32_t>( ::capnp::bounded<0>() * ::capnp::ELEMENTS); From b6ba300d00dc53d441e2b47c84b98e67d67336c4 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 6 Feb 2025 11:05:50 -0500 Subject: [PATCH 219/228] Refactor stdx::select --- test/support/stdx/tuple.h | 35 +++++++++++++++-------------------- 1 file changed, 15 insertions(+), 20 deletions(-) diff --git a/test/support/stdx/tuple.h b/test/support/stdx/tuple.h index 953c041b258..cfddb34f243 100644 --- a/test/support/stdx/tuple.h +++ b/test/support/stdx/tuple.h @@ -97,6 +97,17 @@ void extend( dest); } +template +std::vector select( + std::span records, std::span idxs) { + std::vector dest; + dest.reserve(idxs.size()); + for (auto i : idxs) { + dest.push_back(records[i]); + } + return dest; +} + /** * Selects the positions given by `idx` from each field of `records` to * construct a new tuple. @@ -107,27 +118,11 @@ template std::tuple...> select( std::tuple&...> records, std::span idxs) { - std::tuple...> selected; - - auto select_into = [&idxs]( - std::vector& dest, std::span src) { - dest.reserve(idxs.size()); - for (auto i : idxs) { - dest.push_back(src[i]); - } - }; - - std::apply( - [&](std::vector&... sel) { - std::apply( - [&](const std::vector&... col) { - (select_into.template operator()(sel, std::span(col)), ...); - }, - records); + return std::apply( + [&](const std::vector&... col) { + return std::make_tuple(select(col, idxs)...); }, - selected); - - return selected; + records); } } // namespace stdx From d455c02c6a15c0790422e32422a41333dba0ffc0 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 6 Feb 2025 11:06:49 -0500 Subject: [PATCH 220/228] ::run_execute does not permit 'Cannot load tile offsets' for top-level SECTION --- test/src/unit-sparse-global-order-reader.cc | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 1d3e13e638d..974273d7da7 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2875,7 +2875,9 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { } tiledb_query_free(&query); return; - } else if (err.find("Cannot load tile offsets") != std::string::npos) { + } else if ( + std::is_same_v && + err.find("Cannot load tile offsets") != std::string::npos) { // not enough memory budget for tile offsets, don't bother asserting // about it (for now?) tiledb_query_free(&query); From 0b3fd1ce2e0f0e2aeed278d9df28de47af9432c8 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 6 Feb 2025 11:10:15 -0500 Subject: [PATCH 221/228] Add merge bound duplication test --- test/src/unit-sparse-global-order-reader.cc | 99 ++++++++++++++++++++- 1 file changed, 97 insertions(+), 2 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 974273d7da7..1da28111769 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -69,6 +69,9 @@ using tiledb::test::templates::AttributeType; using tiledb::test::templates::DimensionType; using tiledb::test::templates::FragmentType; +template +using Subarray1DType = std::vector>; + template using Subarray2DType = std::vector>, @@ -1488,6 +1491,86 @@ TEST_CASE_METHOD( } } +/** + * Tests that the reader will not yield duplicate coordinates if + * coordinates in loaded tiles are equal to the merge bound, + * and the merge bound is an actual datum in yet-to-be-loaded tiles. + * + * Example: + * many fragments which overlap at the ends + * [0, 1000], [1000, 2000], [2000, 3000] + * If we can load the tiles of the first two fragments but not + * the third, then the merge bound will be 2000. But it is only + * correct to emit the 2000 from the second fragment if + * duplicates are allowed. + * + * This test illustrates that the merge bound must not be an + * inclusive bound (unless duplicates are allowed). + */ +TEST_CASE_METHOD( + CSparseGlobalOrderFx, + "Sparse global order reader: merge bound duplication", + "[sparse-global-order][rest][rapidcheck]") { + auto doit = [this]( + size_t num_fragments, + size_t fragment_size, + size_t num_user_cells, + size_t tile_capacity, + bool allow_dups, + const Subarray1DType& subarray = {}) { + FxRun1D instance; + instance.num_user_cells = num_user_cells; + instance.subarray = subarray; + instance.memory.total_budget_ = "50000"; + instance.memory.ratio_array_data_ = "0.5"; + instance.array.capacity_ = tile_capacity; + instance.array.allow_dups_ = allow_dups; + instance.array.dimension_.domain.lower_bound = 0; + instance.array.dimension_.domain.upper_bound = + static_cast(num_fragments * fragment_size); + + for (size_t f = 0; f < num_fragments; f++) { + templates::Fragment1D fragment; + fragment.dim_.resize(fragment_size); + std::iota( + fragment.dim_.begin(), fragment.dim_.end(), f * (fragment_size - 1)); + + auto& atts = std::get<0>(fragment.atts_); + atts = fragment.dim_; // we just want to avoid the complexity of which + // fragment wins the dedup + + instance.fragments.push_back(fragment); + } + + instance.num_user_cells = num_user_cells; + + run(instance); + }; + + SECTION("Example") { + doit.operator()(16, 16, 1024, 16, false); + } + + SECTION("Rapidcheck") { + rc::prop("rapidcheck merge bound duplication", [doit]() { + const size_t num_fragments = *rc::gen::inRange(4, 32); + const size_t fragment_size = *rc::gen::inRange(2, 256); + const size_t num_user_cells = 1024; + const size_t tile_capacity = *rc::gen::inRange(1, fragment_size); + const bool allow_dups = *rc::gen::arbitrary(); + const auto subarray = *rc::make_subarray_1d(templates::Domain( + 0, static_cast(num_fragments * fragment_size))); + doit.operator()( + num_fragments, + fragment_size, + num_user_cells, + tile_capacity, + allow_dups, + subarray); + }); + } +} + /** * Tests that the reader will not yield out of order when * the tile MBRs in a fragment are not in the global order. @@ -2789,7 +2872,7 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { sm::GlobalCellCmp globalcmp(array->array()->array_schema_latest().domain()); - std::sort(idxs.begin(), idxs.end(), [&](uint64_t ia, uint64_t ib) -> bool { + auto icmp = [&](uint64_t ia, uint64_t ib) -> bool { return std::apply( [&globalcmp, ia, ib](const std::vector&... dims) { const auto l = std::make_tuple(dims[ia]...); @@ -2799,7 +2882,19 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { templates::global_cell_cmp_std_tuple(r)); }, expect.dimensions()); - }); + }; + + std::sort(idxs.begin(), idxs.end(), icmp); + + if (!instance.allow_duplicates()) { + std::set dedup(icmp); + for (const auto& idx : idxs) { + dedup.insert(idx); + } + + idxs.clear(); + idxs.insert(idxs.end(), dedup.begin(), dedup.end()); + } expect.dimensions() = stdx::select( stdx::reference_tuple(expect.dimensions()), std::span(idxs)); From 221c79ede110c6ebe78b7f82be866bea9397435a Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 6 Feb 2025 11:21:19 -0500 Subject: [PATCH 222/228] add_next_cell checks equality with merge bound --- .../readers/sparse_global_order_reader.cc | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc index cb40f455097..5ab35f807d8 100644 --- a/tiledb/sm/query/readers/sparse_global_order_reader.cc +++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc @@ -1530,15 +1530,19 @@ AddNextCellResult SparseGlobalOrderReader::add_next_cell_to_queue( // tiles then it is not correct to emit it; hopefully we clear out // a tile somewhere and trying again will make progress. // - // We can skip the comparison if the merge bound fragment is the same - // as the current fragment because that is enough to tell us that - // the coordinates are in order. + // If the next cell is equal to the merge bound, then it is only + // correct to add it if duplicates are allowed. if (merge_bound.has_value()) { GlobalCellCmp cmp(array_schema_.domain()); - if (cmp(*merge_bound, rc)) { - // more tiles needed, out-of-order tiles is a possibility if we - // continue - return AddNextCellResult::MergeBound; + if (array_schema_.allows_dups()) { + if (cmp(*merge_bound, rc)) { + return AddNextCellResult::MergeBound; + } + } else { + // `!(rc < *merge_bound)`, i.e. `*merge_bound <= rc` + if (!cmp(rc, *merge_bound)) { + return AddNextCellResult::MergeBound; + } } } From 2a6839b17ec3f5b8d3c7f833d191648b4dace316 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 6 Feb 2025 13:20:19 -0500 Subject: [PATCH 223/228] Toggle allow_dups in some of the rapidcheck tests --- test/src/unit-sparse-global-order-reader.cc | 131 +++++++++++++++----- test/support/rapidcheck/array_templates.h | 15 ++- 2 files changed, 109 insertions(+), 37 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 1da28111769..2fc55a74ff5 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -948,10 +948,12 @@ static std::optional can_complete_in_memory_budget( }; /** + * Simulates comparison of a loaded tile to the merge bound. + * * @return true if `rtl.upper < rtr.lower`, i.e. we can process * the entirety of `rtl` before any of `rtr` */ - auto cmp_upper_to_lower = [&](const RT& rtl, const RT& rtr) { + auto cmp_merge_bound = [&](const RT& rtl, const RT& rtr) { const auto rtl_mbr_clamped = instance.clamp( fragment_metadata[rtl.fragment_idx_]->mbr(rtl.tile_idx_)); const sm::RangeUpperBound l_mbr = {.mbr = rtl_mbr_clamped}; @@ -959,7 +961,11 @@ static std::optional can_complete_in_memory_budget( .mbr = fragment_metadata[rtr.fragment_idx_]->mbr(rtr.tile_idx_)}; const int cmp = globalcmp.compare(l_mbr, r_mbr); - return cmp <= 0; + if (instance.allow_duplicates()) { + return cmp <= 0; + } else { + return cmp < 0; + } }; // order all tiles on their lower bound @@ -1013,7 +1019,7 @@ static std::optional can_complete_in_memory_budget( // emit from created result tiles, removing any which are exhausted next_rt = mbr_lower_bound.top(); while (!mbr_upper_bound.empty() && - cmp_upper_to_lower(mbr_upper_bound.top(), next_rt)) { + cmp_merge_bound(mbr_upper_bound.top(), next_rt)) { auto finish_rt = mbr_upper_bound.top(); mbr_upper_bound.pop(); active_tile_size -= @@ -1436,6 +1442,7 @@ TEST_CASE_METHOD( size_t num_fragments, size_t fragment_size, size_t num_user_cells, + bool allow_dups, const std::vector>& subarray = std::vector>()) { const uint64_t total_budget = 100000; @@ -1444,7 +1451,7 @@ TEST_CASE_METHOD( FxRun1D instance; instance.array.capacity_ = num_fragments * 2; instance.array.dimension_.extent = int(num_fragments) * 2; - instance.array.allow_dups_ = true; + instance.array.allow_dups_ = allow_dups; instance.subarray = subarray; instance.memory.total_budget_ = std::to_string(total_budget); @@ -1475,18 +1482,30 @@ TEST_CASE_METHOD( }; SECTION("Example") { - doit.operator()(16, 100, 64); + doit.operator()(16, 100, 64, true); + } + + SECTION("Shrink", "Some examples found by rapidcheck") { + doit.operator()( + 10, 2, 64, false, Subarray1DType{templates::Domain(1, 3)}); + doit.operator()( + 12, + 15, + 1024, + false, + Subarray1DType{templates::Domain(1, 12)}); } SECTION("Rapidcheck") { - rc::prop("rapidcheck many overlapping fragments", [doit]() { + rc::prop("rapidcheck fragment wide overlap", [doit]() { const size_t num_fragments = *rc::gen::inRange(10, 24); const size_t fragment_size = *rc::gen::inRange(2, 200 - 64); const size_t num_user_cells = 1024; + const bool allow_dups = *rc::gen::arbitrary(); const auto subarray = *rc::make_subarray_1d(templates::Domain(1, 200)); doit.operator()( - num_fragments, fragment_size, num_user_cells, subarray); + num_fragments, fragment_size, num_user_cells, allow_dups, subarray); }); } } @@ -1536,8 +1555,8 @@ TEST_CASE_METHOD( fragment.dim_.begin(), fragment.dim_.end(), f * (fragment_size - 1)); auto& atts = std::get<0>(fragment.atts_); - atts = fragment.dim_; // we just want to avoid the complexity of which - // fragment wins the dedup + atts.resize(fragment_size); + std::iota(atts.begin(), atts.end(), f * fragment_size); instance.fragments.push_back(fragment); } @@ -3018,11 +3037,19 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { ASSERTER(expect.dimensions() == outdims); - // Checking attributes is more complicated because equal coords - // can manifest their attributes in any order. + // Checking attributes is more complicated because: + // 1) when dups are off, equal coords will choose the attribute from one + // fragment. 2) when dups are on, the attributes may manifest in any order. // Identify the runs of equal coords and then compare using those size_t attcursor = 0; size_t runlength = 1; + + auto viewtuple = [&](const auto& atttuple, size_t i) { + return std::apply( + [&](const auto&... att) { return std::make_tuple(att[i]...); }, + atttuple); + }; + for (size_t i = 1; i < out.size(); i++) { if (std::apply( [&](const auto&... outdim) { @@ -3030,13 +3057,7 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { }, outdims)) { runlength++; - } else { - auto viewtuple = [&](const auto& atttuple, size_t i) { - return std::apply( - [&](const auto&... att) { return std::make_tuple(att[i]...); }, - atttuple); - }; - + } else if (instance.allow_duplicates()) { std::set outattsrun; std::set expectattsrun; @@ -3047,6 +3068,30 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { ASSERTER(outattsrun == expectattsrun); + attcursor += runlength; + runlength = 1; + } else { + REQUIRE(runlength == 1); + + const auto out = viewtuple(expect.attributes(), i); + + // at least all the attributes will come from the same fragment + if (out != viewtuple(expect.attributes(), i)) { + // the found attribute values should match at least one of the fragments + bool matched = false; + for (size_t f = 0; !matched && f < instance.fragments.size(); f++) { + for (size_t ic = 0; !matched && ic < instance.fragments[f].size(); + ic++) { + if (viewtuple(instance.fragments[f].dimensions(), ic) == + viewtuple(expect.dimensions(), ic)) { + matched = + (viewtuple(instance.fragments[f].attributes(), ic) == out); + } + } + } + ASSERTER(matched); + } + attcursor += runlength; runlength = 1; } @@ -3095,13 +3140,20 @@ struct Arbitrary { using CoordType = tiledb::type::datatype_traits::value_type; auto dimension = gen::arbitrary>(); + auto allow_dups = gen::arbitrary(); auto fragments = gen::mapcat( - dimension, [](templates::Dimension dimension) { - auto fragment = - rc::make_fragment_1d(dimension.domain); + gen::pair(allow_dups, dimension), + [](std::pair> arg) { + bool allow_dups; + templates::Dimension dimension; + std::tie(allow_dups, dimension) = arg; + + auto fragment = rc::make_fragment_1d( + allow_dups, dimension.domain); return gen::tuple( + gen::just(allow_dups), gen::just(dimension), make_subarray_1d(dimension.domain), gen::nonEmpty( @@ -3113,23 +3165,27 @@ struct Arbitrary { return gen::apply( [](std::tuple< + bool, templates::Dimension, std::vector>, std::vector>> fragments, - int num_user_cells) { + int num_user_cells, + bool allow_dups) { FxRun1D instance; std::tie( + instance.array.allow_dups_, instance.array.dimension_, instance.subarray, instance.fragments) = fragments; instance.num_user_cells = num_user_cells; - instance.array.allow_dups_ = true; + instance.array.allow_dups_ = allow_dups; return instance; }, fragments, - num_user_cells); + num_user_cells, + gen::arbitrary()); } }; @@ -3172,16 +3228,23 @@ struct Arbitrary { tiledb::type::datatype_traits::value_type, Coord1Type>); + auto allow_dups = gen::arbitrary(); auto d0 = gen::arbitrary>(); auto d1 = gen::arbitrary>(); - auto fragments = gen::mapcat(gen::pair(d0, d1), [](auto dimensions) { + auto fragments = gen::mapcat(gen::tuple(allow_dups, d0, d1), [](auto arg) { + bool allow_dups; + templates::Dimension d0; + templates::Dimension d1; + std::tie(allow_dups, d0, d1) = arg; + auto fragment = rc::make_fragment_2d( - dimensions.first.domain, dimensions.second.domain); + allow_dups, d0.domain, d1.domain); return gen::tuple( - gen::just(dimensions.first), - gen::just(dimensions.second), - make_subarray_2d(dimensions.first.domain, dimensions.second.domain), + gen::just(allow_dups), + gen::just(d0), + gen::just(d1), + make_subarray_2d(d0.domain, d1.domain), gen::nonEmpty( gen::container>(fragment))); }); @@ -3197,12 +3260,14 @@ struct Arbitrary { tiledb_layout_t cell_order) { FxRun2D instance; std::tie( - instance.d1, instance.d2, instance.subarray, instance.fragments) = - fragments; + instance.allow_dups, + instance.d1, + instance.d2, + instance.subarray, + instance.fragments) = fragments; - // TODO: capacity, subarray + // TODO: capacity instance.num_user_cells = num_user_cells; - instance.allow_dups = true; instance.tile_order_ = tile_order; instance.cell_order_ = cell_order; diff --git a/test/support/rapidcheck/array_templates.h b/test/support/rapidcheck/array_templates.h index 524fb7f650d..2ec421ff69f 100644 --- a/test/support/rapidcheck/array_templates.h +++ b/test/support/rapidcheck/array_templates.h @@ -165,14 +165,17 @@ Gen> make_range(const templates::Domain& domain) { } template -Gen> make_fragment_1d(const Domain& d) { +Gen> make_fragment_1d( + bool allow_duplicates, const Domain& d) { auto coord = make_coordinate(d); auto cell = gen::tuple(coord, gen::arbitrary()...); using Cell = std::tuple; - auto cells = gen::nonEmpty(gen::container>(cell)); + auto cells = gen::nonEmpty( + allow_duplicates ? gen::container>(cell) : + gen::unique>(cell)); return gen::map(cells, [](std::vector cells) { std::vector coords; @@ -191,7 +194,9 @@ Gen> make_fragment_1d(const Domain& d) { template Gen> make_fragment_2d( - const Domain& d1, const templates::Domain& d2) { + bool allow_duplicates, + const Domain& d1, + const templates::Domain& d2) { auto coord_d1 = make_coordinate(d1); auto coord_d2 = make_coordinate(d2); @@ -199,7 +204,9 @@ Gen> make_fragment_2d( auto cell = gen::tuple(coord_d1, coord_d2, gen::arbitrary()...); - auto cells = gen::nonEmpty(gen::container>(cell)); + auto cells = gen::nonEmpty( + allow_duplicates ? gen::container>(cell) : + gen::unique>(cell)); return gen::map(cells, [](std::vector cells) { std::vector coords_d1; From d9f761036a008ffea70087ab8cc0519981f0e8f9 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 6 Feb 2025 15:24:35 -0500 Subject: [PATCH 224/228] Fix rapidcheck allow_dups issues --- test/src/unit-sparse-global-order-reader.cc | 24 +++++++++++++++------ test/support/rapidcheck/array_templates.h | 10 +++++++-- test/support/src/array_templates.h | 11 ++++++++++ 3 files changed, 37 insertions(+), 8 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 2fc55a74ff5..03007cf0a00 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -3169,8 +3169,7 @@ struct Arbitrary { templates::Dimension, std::vector>, std::vector>> fragments, - int num_user_cells, - bool allow_dups) { + int num_user_cells) { FxRun1D instance; std::tie( instance.array.allow_dups_, @@ -3179,13 +3178,11 @@ struct Arbitrary { instance.fragments) = fragments; instance.num_user_cells = num_user_cells; - instance.array.allow_dups_ = allow_dups; return instance; }, fragments, - num_user_cells, - gen::arbitrary()); + num_user_cells); } }; @@ -3232,7 +3229,22 @@ struct Arbitrary { auto d0 = gen::arbitrary>(); auto d1 = gen::arbitrary>(); - auto fragments = gen::mapcat(gen::tuple(allow_dups, d0, d1), [](auto arg) { + auto domain = + gen::suchThat(gen::tuple(allow_dups, d0, d1), [](const auto& arg) { + bool allow_dups; + templates::Dimension d0; + templates::Dimension d1; + std::tie(allow_dups, d0, d1) = arg; + if (allow_dups) { + return true; + } else { + // need to ensure that rapidcheck uniqueness can generate enough + // cases + return (d0.domain.num_cells() + d1.domain.num_cells()) >= 12; + } + }); + + auto fragments = gen::mapcat(domain, [](auto arg) { bool allow_dups; templates::Dimension d0; templates::Dimension d1; diff --git a/test/support/rapidcheck/array_templates.h b/test/support/rapidcheck/array_templates.h index 2ec421ff69f..95f8b671030 100644 --- a/test/support/rapidcheck/array_templates.h +++ b/test/support/rapidcheck/array_templates.h @@ -173,9 +173,11 @@ Gen> make_fragment_1d( using Cell = std::tuple; + auto uniqueCoords = [](const Cell& cell) { return std::get<0>(cell); }; + auto cells = gen::nonEmpty( allow_duplicates ? gen::container>(cell) : - gen::unique>(cell)); + gen::uniqueBy>(cell, uniqueCoords)); return gen::map(cells, [](std::vector cells) { std::vector coords; @@ -204,9 +206,13 @@ Gen> make_fragment_2d( auto cell = gen::tuple(coord_d1, coord_d2, gen::arbitrary()...); + auto uniqueCoords = [](const Cell& cell) { + return std::make_pair(std::get<0>(cell), std::get<1>(cell)); + }; + auto cells = gen::nonEmpty( allow_duplicates ? gen::container>(cell) : - gen::unique>(cell)); + gen::uniqueBy>(cell, uniqueCoords)); return gen::map(cells, [](std::vector cells) { std::vector coords_d1; diff --git a/test/support/src/array_templates.h b/test/support/src/array_templates.h index 024cc6176c7..d70d2217b20 100644 --- a/test/support/src/array_templates.h +++ b/test/support/src/array_templates.h @@ -142,6 +142,17 @@ struct Domain { , upper_bound(std::max(d1, d2)) { } + uint64_t num_cells() const { + // FIXME: this is incorrect for 64-bit domains which need to check overflow + if (std::is_signed::value) { + return static_cast(upper_bound) - + static_cast(lower_bound) + 1; + } else { + return static_cast(upper_bound) - + static_cast(lower_bound) + 1; + } + } + bool contains(D point) const { return lower_bound <= point && point <= upper_bound; } From 8451b666be17efc68496dc8d31d3ae9408e30f21 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 6 Feb 2025 15:41:00 -0500 Subject: [PATCH 225/228] Fix uniqueness of rapidcheck 1d test --- test/src/unit-sparse-global-order-reader.cc | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 03007cf0a00..687a1e58457 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -3142,9 +3142,22 @@ struct Arbitrary { auto dimension = gen::arbitrary>(); auto allow_dups = gen::arbitrary(); + auto domain = + gen::suchThat(gen::pair(allow_dups, dimension), [](const auto& domain) { + bool allow_dups; + templates::Dimension dimension; + std::tie(allow_dups, dimension) = domain; + if (allow_dups) { + return true; + } else { + // need to ensure that rapidcheck uniqueness can generate enough + // cases + return dimension.domain.num_cells() >= 256; + } + }); + auto fragments = gen::mapcat( - gen::pair(allow_dups, dimension), - [](std::pair> arg) { + domain, [](std::pair> arg) { bool allow_dups; templates::Dimension dimension; std::tie(allow_dups, dimension) = arg; From 9c15ce3e092f5aafc6521ffaef8a19132dcf7982 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 6 Feb 2025 16:12:30 -0500 Subject: [PATCH 226/228] Revert "Refactor stdx::select" This reverts commit b6ba300d00dc53d441e2b47c84b98e67d67336c4. --- test/support/stdx/tuple.h | 35 ++++++++++++++++++++--------------- 1 file changed, 20 insertions(+), 15 deletions(-) diff --git a/test/support/stdx/tuple.h b/test/support/stdx/tuple.h index cfddb34f243..953c041b258 100644 --- a/test/support/stdx/tuple.h +++ b/test/support/stdx/tuple.h @@ -97,17 +97,6 @@ void extend( dest); } -template -std::vector select( - std::span records, std::span idxs) { - std::vector dest; - dest.reserve(idxs.size()); - for (auto i : idxs) { - dest.push_back(records[i]); - } - return dest; -} - /** * Selects the positions given by `idx` from each field of `records` to * construct a new tuple. @@ -118,11 +107,27 @@ template std::tuple...> select( std::tuple&...> records, std::span idxs) { - return std::apply( - [&](const std::vector&... col) { - return std::make_tuple(select(col, idxs)...); + std::tuple...> selected; + + auto select_into = [&idxs]( + std::vector& dest, std::span src) { + dest.reserve(idxs.size()); + for (auto i : idxs) { + dest.push_back(src[i]); + } + }; + + std::apply( + [&](std::vector&... sel) { + std::apply( + [&](const std::vector&... col) { + (select_into.template operator()(sel, std::span(col)), ...); + }, + records); }, - records); + selected); + + return selected; } } // namespace stdx From 76fe5e3000f0d8e1938b3a57936960fa58521e53 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 6 Feb 2025 16:15:13 -0500 Subject: [PATCH 227/228] msvc errors --- test/src/unit-sparse-global-order-reader.cc | 24 +++++++++++---------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 687a1e58457..7502808ead3 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -1552,11 +1552,13 @@ TEST_CASE_METHOD( templates::Fragment1D fragment; fragment.dim_.resize(fragment_size); std::iota( - fragment.dim_.begin(), fragment.dim_.end(), f * (fragment_size - 1)); + fragment.dim_.begin(), + fragment.dim_.end(), + static_cast(f * (fragment_size - 1))); auto& atts = std::get<0>(fragment.atts_); atts.resize(fragment_size); - std::iota(atts.begin(), atts.end(), f * fragment_size); + std::iota(atts.begin(), atts.end(), static_cast(f * fragment_size)); instance.fragments.push_back(fragment); } @@ -2989,16 +2991,16 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { } tiledb_query_free(&query); return; - } else if ( - std::is_same_v && - err.find("Cannot load tile offsets") != std::string::npos) { - // not enough memory budget for tile offsets, don't bother asserting - // about it (for now?) - tiledb_query_free(&query); - return; - } else { - ASSERTER("" == err); } + if constexpr (std::is_same_v) { + if (err.find("Cannot load tile offsets") != std::string::npos) { + // not enough memory budget for tile offsets, don't bother asserting + // about it (for now?) + tiledb_query_free(&query); + return; + } + } + ASSERTER("" == err); } tiledb_query_status_t status; From 7992ba471b6203cc6a4b667f1c9f45e0fc74a468 Mon Sep 17 00:00:00 2001 From: Ryan Roelke Date: Thu, 6 Feb 2025 16:40:13 -0500 Subject: [PATCH 228/228] Rapidcheck ignore 'Cannot allocate space for preprocess' --- test/src/unit-sparse-global-order-reader.cc | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 7502808ead3..678ccd7112a 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -2993,6 +2993,14 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { return; } if constexpr (std::is_same_v) { + if (err.find( + "Cannot allocate space for preprocess result tile ID list")) { + // not enough memory to determine tile order + // we can probably make some assertions about what this should have + // looked like but for now we'll let it go + tiledb_query_free(&query); + return; + } if (err.find("Cannot load tile offsets") != std::string::npos) { // not enough memory budget for tile offsets, don't bother asserting // about it (for now?)