From ca7bd07970380dd5edb0ca76fe853a514f7ab581 Mon Sep 17 00:00:00 2001 From: Shaun M Reed Date: Thu, 30 Jan 2025 10:33:42 -0500 Subject: [PATCH] Add endpoint for REST version and capabilities. (#5429) This adds the REST capabilities endpoint to `RestClientRemote` and serialization for the `RestCapabilities` response. The endpoint is currently not in use internally and there is no way to make the request using public APIs. The `RestCapabilities` response currently provides the TileDB core version deployed to REST, and the minimum TileDB core client version supported by the REST server. The response may be updated in the future to add more information as needed - [discussion in shortcut](https://app.shortcut.com/tiledb-inc/story/61403/rest-route-to-check-server-side-libtiledb-version-and-capabilities#activity-62215) and [design document](https://www.notion.so/Design-REST-route-to-check-server-side-libtiledb-version-181326501175800ea184eb6909b65d20?pvs=4) --- TYPE: FEATURE DESC: Add endpoint for REST version and capabilities. --------- Co-authored-by: Theodore Tsirpanis --- tiledb/CMakeLists.txt | 1 + tiledb/sm/rest/curl.cc | 5 +- tiledb/sm/rest/rest_capabilities.h | 82 ++++ tiledb/sm/rest/rest_client.h | 25 ++ tiledb/sm/rest/rest_client_remote.cc | 20 + tiledb/sm/rest/rest_client_remote.h | 39 +- tiledb/sm/serialization/rest_capabilities.cc | 149 +++++++ tiledb/sm/serialization/rest_capabilities.h | 62 +++ tiledb/sm/serialization/tiledb-rest.capnp | 11 + tiledb/sm/serialization/tiledb-rest.capnp.c++ | 167 +++++++ tiledb/sm/serialization/tiledb-rest.capnp.h | 418 ++++++++++++++++++ 11 files changed, 977 insertions(+), 2 deletions(-) create mode 100644 tiledb/sm/rest/rest_capabilities.h create mode 100644 tiledb/sm/serialization/rest_capabilities.cc create mode 100644 tiledb/sm/serialization/rest_capabilities.h diff --git a/tiledb/CMakeLists.txt b/tiledb/CMakeLists.txt index 4ecaf58feae..f8ed77d2059 100644 --- a/tiledb/CMakeLists.txt +++ b/tiledb/CMakeLists.txt @@ -296,6 +296,7 @@ set(TILEDB_CORE_SOURCES ${TILEDB_CORE_INCLUDE_DIR}/tiledb/sm/serialization/query_plan.cc ${TILEDB_CORE_INCLUDE_DIR}/tiledb/sm/serialization/consolidation.cc ${TILEDB_CORE_INCLUDE_DIR}/tiledb/sm/serialization/vacuum.cc + ${TILEDB_CORE_INCLUDE_DIR}/tiledb/sm/serialization/rest_capabilities.cc ${TILEDB_CORE_INCLUDE_DIR}/tiledb/sm/stats/global_stats.cc ${TILEDB_CORE_INCLUDE_DIR}/tiledb/sm/stats/stats.cc ${TILEDB_CORE_INCLUDE_DIR}/tiledb/sm/storage_manager/cancellation_source.cc diff --git a/tiledb/sm/rest/curl.cc b/tiledb/sm/rest/curl.cc index 27ce299135f..49a2fd75c50 100644 --- a/tiledb/sm/rest/curl.cc +++ b/tiledb/sm/rest/curl.cc @@ -162,7 +162,9 @@ size_t write_header_callback( auto* const header_buffer = static_cast(res_data); auto* const pmHeader = static_cast(userdata); - if (pmHeader->uri->empty()) { + // If we have enabled caching of the redirect URI ensure it's not empty. + // If disabled for this request, do not treat an empty asset URI as an error. + if (pmHeader->should_cache_redirect && pmHeader->uri->empty()) { LOG_ERROR("Rest components as array_ns and array_uri cannot be empty"); return 0; } @@ -540,6 +542,7 @@ Status Curl::make_curl_request_common( data->get_offset(); } + stats->add_counter("rest_http_requests", 1); // <= because the 0ths retry is actually the initial request for (uint8_t i = 0; i <= retry_count_; i++) { WriteCbState write_cb_state; diff --git a/tiledb/sm/rest/rest_capabilities.h b/tiledb/sm/rest/rest_capabilities.h new file mode 100644 index 00000000000..ab98ede1b77 --- /dev/null +++ b/tiledb/sm/rest/rest_capabilities.h @@ -0,0 +1,82 @@ +/** + * @file rest_capabilities.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 + * + * Helper struct to encapsulate REST supported versions and capabilities. + */ + +namespace tiledb::sm { + +struct RestCapabilities { + struct TileDBVersion { + TileDBVersion() = default; + + TileDBVersion(int major, int minor, int patch) + : major_(major) + , minor_(minor) + , patch_(patch) { + } + + bool operator==(const TileDBVersion& rhs) const = default; + + uint16_t major_, minor_, patch_; + }; + + /** + * Default constructor allows the class to be constructed without submitting + * a REST request to initialize member variables. + */ + RestCapabilities() = default; + + ~RestCapabilities() = default; + + /** + * Fully initialized constructor contains all REST version and capabilities + * information required for handling edge cases between client & server + * releases. + */ + RestCapabilities( + TileDBVersion rest_version, TileDBVersion rest_minimum_version) + : detected_(true) + , rest_tiledb_version_(rest_version) + , rest_minimum_supported_version_(rest_minimum_version) { + } + + bool operator==(const RestCapabilities& rhs) const = default; + + /// Whether or not the REST capabilities have been initialized. + bool detected_ = false; + + /// The currently deployed TileDB version available on the REST server. + TileDBVersion rest_tiledb_version_{}; + + /// The minimum TileDB version supported by the REST server. + TileDBVersion rest_minimum_supported_version_{}; +}; + +} // namespace tiledb::sm diff --git a/tiledb/sm/rest/rest_client.h b/tiledb/sm/rest/rest_client.h index 3a823f0804f..63cd3c3648f 100644 --- a/tiledb/sm/rest/rest_client.h +++ b/tiledb/sm/rest/rest_client.h @@ -175,6 +175,7 @@ #include "tiledb/common/status.h" #include "tiledb/common/thread_pool/thread_pool.h" #include "tiledb/sm/group/group.h" +#include "tiledb/sm/rest/rest_capabilities.h" #include "tiledb/sm/serialization/query.h" #include "tiledb/sm/stats/stats.h" @@ -259,6 +260,8 @@ class RestClient { std::string rest_server_; public: + using TileDBVersion = RestCapabilities::TileDBVersion; + RestClient(const Config& config); virtual ~RestClient() = default; @@ -294,6 +297,22 @@ class RestClient { return rest_server_; } + /// Operation disabled in base class. + inline virtual const TileDBVersion& rest_tiledb_version() const { + throw RestClientDisabledException(); + } + + /// Operation disabled in base class. + inline virtual const TileDBVersion& rest_minimum_supported_tiledb_version() + const { + throw RestClientDisabledException(); + } + + /// Operation disabled in base class. + inline virtual bool rest_capabilities_detected() const { + throw RestClientDisabledException(); + } + //------------------------------------------------------- // Rest client operations //------------------------------------------------------- @@ -473,6 +492,12 @@ class RestClient { post_consolidation_plan_from_rest(const URI&, const Config&, uint64_t) { throw RestClientDisabledException(); } + + /// Operation disabled in base class. + inline virtual const tiledb::sm::RestCapabilities& + get_capabilities_from_rest() const { + throw RestClientDisabledException(); + } }; // Forward declaration. diff --git a/tiledb/sm/rest/rest_client_remote.cc b/tiledb/sm/rest/rest_client_remote.cc index 28087b8ffd0..1ce36fba250 100644 --- a/tiledb/sm/rest/rest_client_remote.cc +++ b/tiledb/sm/rest/rest_client_remote.cc @@ -1516,4 +1516,24 @@ RestClientRemote::post_consolidation_plan_from_rest( serialization_type_, returned_data); } +const RestCapabilities& RestClientRemote::get_capabilities_from_rest() const { + // Return early if already detected REST capabilities for this REST client. + if (rest_capabilities_.detected_) { + return rest_capabilities_; + } + + // Init curl and form the URL + Curl curlc(logger_); + std::unordered_map redirect_meta; + throw_if_not_ok(curlc.init( + config_, extra_headers_, &redirect_meta, &redirect_mtx_, false)); + const std::string url = rest_server_ + "/v4/capabilities"; + + Buffer data; + throw_if_not_ok(curlc.get_data(stats_, url, serialization_type_, &data, {})); + rest_capabilities_ = + serialization::rest_capabilities_deserialize(serialization_type_, data); + return rest_capabilities_; +} + } // namespace tiledb::sm diff --git a/tiledb/sm/rest/rest_client_remote.h b/tiledb/sm/rest/rest_client_remote.h index cf2c082596a..b2efa963bac 100644 --- a/tiledb/sm/rest/rest_client_remote.h +++ b/tiledb/sm/rest/rest_client_remote.h @@ -42,6 +42,7 @@ // clang-format off #include "tiledb/sm/serialization/capnp_utils.h" #include "tiledb/sm/serialization/array.h" +#include "tiledb/sm/serialization/array_schema.h" #include "tiledb/sm/serialization/array_schema_evolution.h" #include "tiledb/sm/serialization/config.h" #include "tiledb/sm/serialization/consolidation.h" @@ -53,6 +54,7 @@ #include "tiledb/sm/serialization/query_plan.h" #include "tiledb/sm/serialization/tiledb-rest.capnp.h" #include "tiledb/sm/serialization/vacuum.h" +#include "tiledb/sm/serialization/rest_capabilities.h" #include "tiledb/sm/rest/curl.h" // must be included last to avoid Windows.h // clang-format on @@ -73,7 +75,6 @@ #include "tiledb/sm/query/query_buffer.h" #include "tiledb/sm/query/query_remote_buffer_storage.h" #include "tiledb/sm/rest/rest_client.h" -#include "tiledb/sm/serialization/array_schema.h" #include "tiledb/type/apply_with_type.h" using namespace tiledb::common; @@ -117,6 +118,32 @@ class RestClientRemote : public RestClient { * */ static bool use_refactored_query(const Config& config); + /** + * @return TileDB core version currently deployed to the REST server. + */ + inline const TileDBVersion& rest_tiledb_version() const override { + return get_capabilities_from_rest().rest_tiledb_version_; + } + + /** + * @return Minimum TileDB core version currently supported by the REST server. + */ + inline const TileDBVersion& rest_minimum_supported_tiledb_version() + const override { + return get_capabilities_from_rest().rest_minimum_supported_version_; + } + + /** + * Check if REST capabilities are currently known to the RestClient. This + * will not attempt to initialize them if they are currently unknown. + * + * @return True if RestCapabilities member has been initialized by a previous + * REST capabilities endpoint request, else False. + */ + inline bool rest_capabilities_detected() const override { + return rest_capabilities_.detected_; + } + /** * Check if an array exists by making a REST call. To start with this fetches * the schema but ignores the body returned if non-error @@ -444,6 +471,13 @@ class RestClientRemote : public RestClient { std::vector> post_consolidation_plan_from_rest( const URI& uri, const Config& config, uint64_t fragment_size) override; + /** + * Get REST capabilities from the REST server. + * + * @return RestCapabilities object initialized with context from REST server. + */ + const RestCapabilities& get_capabilities_from_rest() const override; + private: /* ********************************* */ /* PRIVATE ATTRIBUTES */ @@ -487,6 +521,9 @@ class RestClientRemote : public RestClient { /** The class MemoryTracker. */ shared_ptr memory_tracker_; + /** REST supported TileDB versions and capabilities. */ + mutable RestCapabilities rest_capabilities_; + /* ********************************* */ /* PRIVATE METHODS */ /* ********************************* */ diff --git a/tiledb/sm/serialization/rest_capabilities.cc b/tiledb/sm/serialization/rest_capabilities.cc new file mode 100644 index 00000000000..416b1225e75 --- /dev/null +++ b/tiledb/sm/serialization/rest_capabilities.cc @@ -0,0 +1,149 @@ +/** + * @file rest_capabilities.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 defines serialization for REST version information. + */ + +#include + +// clang-format off +#ifdef TILEDB_SERIALIZATION +#include +#include +#include +#endif +// clang-format on + +#include "tiledb/sm/enums/serialization_type.h" +#include "tiledb/sm/rest/rest_client.h" +#include "tiledb/sm/serialization/rest_capabilities.h" + +using namespace tiledb::common; + +namespace tiledb::sm::serialization { + +class RestCapabilitiesSerializationException : public StatusException { + public: + explicit RestCapabilitiesSerializationException(const std::string& message) + : StatusException("[TileDB::Serialization][RestCapabilities]", message) { + } +}; + +class RestCapabilitiesSerializationDisabledException + : public RestCapabilitiesSerializationException { + public: + explicit RestCapabilitiesSerializationDisabledException() + : RestCapabilitiesSerializationException( + "Cannot (de)serialize; serialization not enabled.") { + } +}; + +#ifdef TILEDB_SERIALIZATION + +RestCapabilities rest_capabilities_deserialize( + SerializationType serialization_type, + span serialized_response) { + try { + switch (serialization_type) { + case SerializationType::JSON: { + ::capnp::MallocMessageBuilder message_builder; + capnp::RestCapabilities::Builder rest_capabilities_builder = + message_builder.initRoot(); + utils::decode_json_message( + serialized_response, rest_capabilities_builder); + capnp::RestCapabilities::Reader rest_capabilities_reader = + rest_capabilities_builder.asReader(); + return rest_capabilities_from_capnp(rest_capabilities_reader); + } + case SerializationType::CAPNP: { + const auto mBytes = + reinterpret_cast(serialized_response.data()); + ::capnp::FlatArrayMessageReader reader(kj::arrayPtr( + reinterpret_cast(mBytes), + serialized_response.size() / sizeof(::capnp::word))); + capnp::RestCapabilities::Reader rest_capabilities_reader = + reader.getRoot(); + return rest_capabilities_from_capnp(rest_capabilities_reader); + } + default: { + throw RestCapabilitiesSerializationException( + "Error deserializing REST version; Unknown serialization type " + "passed"); + } + } + + } catch (kj::Exception& e) { + throw RestCapabilitiesSerializationException( + "Error deserializing REST version; kj::Exception: " + + std::string(e.getDescription().cStr())); + } catch (std::exception& e) { + throw RestCapabilitiesSerializationException( + "Error deserializing REST version; exception " + std::string(e.what())); + } +} + +RestCapabilities rest_capabilities_from_capnp( + const capnp::RestCapabilities::Reader& rest_capabilities_reader) { + RestClient::TileDBVersion rest_version{}, rest_minimum_version{}; + if (rest_capabilities_reader.hasDeployedTileDBVersion()) { + auto version_reader = rest_capabilities_reader.getDeployedTileDBVersion(); + rest_version.major_ = version_reader.getMajor(); + rest_version.minor_ = version_reader.getMinor(); + rest_version.patch_ = version_reader.getPatch(); + } else { + throw RestCapabilitiesSerializationException( + "Failed to deserialize REST capabilities with no deployed TileDB " + "version."); + } + + if (rest_capabilities_reader.hasMinimumSupportedTileDBClientVersion()) { + auto version_reader = + rest_capabilities_reader.getMinimumSupportedTileDBClientVersion(); + rest_minimum_version.major_ = version_reader.getMajor(); + rest_minimum_version.minor_ = version_reader.getMinor(); + rest_minimum_version.patch_ = version_reader.getPatch(); + } else { + throw RestCapabilitiesSerializationException( + "Failed to deserialize REST capabilities with no minimum supported " + "TileDB version."); + } + + return {rest_version, rest_minimum_version}; +} + +#else + +RestCapabilities rest_capabilities_deserialize( + SerializationType, span) { + throw RestCapabilitiesSerializationDisabledException(); +} + +#endif // TILEDB_SERIALIZATION + +} // namespace tiledb::sm::serialization diff --git a/tiledb/sm/serialization/rest_capabilities.h b/tiledb/sm/serialization/rest_capabilities.h new file mode 100644 index 00000000000..6702f7158e5 --- /dev/null +++ b/tiledb/sm/serialization/rest_capabilities.h @@ -0,0 +1,62 @@ +/** + * @file rest_capabilities.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 declares serialization functions for REST version information. + */ + +#ifndef TILEDB_SERIALIZATION_REST_CAPABILITIES_H +#define TILEDB_SERIALIZATION_REST_CAPABILITIES_H + +#ifdef TILEDB_SERIALIZATION +#include "tiledb/sm/serialization/capnp_utils.h" +#endif + +using namespace tiledb::common; + +namespace tiledb::sm { + +struct RestCapabilities; +enum class SerializationType : uint8_t; + +namespace serialization { + +RestCapabilities rest_capabilities_deserialize( + SerializationType serialization_type, span serialized_response); + +#ifdef TILEDB_SERIALIZATION + +RestCapabilities rest_capabilities_from_capnp( + const capnp::RestCapabilities::Reader& rest_version_reader); + +#endif + +} // namespace serialization +} // namespace tiledb::sm + +#endif // TILEDB_SERIALIZATION_REST_CAPABILITIES_H diff --git a/tiledb/sm/serialization/tiledb-rest.capnp b/tiledb/sm/serialization/tiledb-rest.capnp index 2d30e7528a2..b3661f9b7c1 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp +++ b/tiledb/sm/serialization/tiledb-rest.capnp @@ -1391,3 +1391,14 @@ struct ObjectInfoResponse { objectType @0 :ObjectType; # The object's type (array or group). } + +struct TileDBVersion { + major @0 :UInt16; + minor @1 :UInt16; + patch @2 :UInt16; +} + +struct RestCapabilities { + deployedTileDBVersion @0 :TileDBVersion; + minimumSupportedTileDBClientVersion @1 :TileDBVersion; +} diff --git a/tiledb/sm/serialization/tiledb-rest.capnp.c++ b/tiledb/sm/serialization/tiledb-rest.capnp.c++ index 874fe7ebe0d..21b54dff743 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp.c++ +++ b/tiledb/sm/serialization/tiledb-rest.capnp.c++ @@ -10649,6 +10649,149 @@ const ::capnp::_::RawSchema s_87f0466598bb29be = { 1, 1, i_87f0466598bb29be, nullptr, nullptr, { &s_87f0466598bb29be, nullptr, nullptr, 0, 0, nullptr }, false }; #endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<63> b_ff44627d34d063ab = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 171, 99, 208, 52, 125, 98, 68, 255, + 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, 2, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 175, 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, 84, 105, 108, 101, 68, 66, + 86, 101, 114, 115, 105, 111, 110, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 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, + 69, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 3, 0, 1, 0, + 76, 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, + 73, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 68, 0, 0, 0, 3, 0, 1, 0, + 80, 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, + 77, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 3, 0, 1, 0, + 84, 0, 0, 0, 2, 0, 1, 0, + 109, 97, 106, 111, 114, 0, 0, 0, + 7, 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, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 105, 110, 111, 114, 0, 0, 0, + 7, 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, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 116, 99, 104, 0, 0, 0, + 7, 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, + 7, 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_ff44627d34d063ab = b_ff44627d34d063ab.words; +#if !CAPNP_LITE +static const uint16_t m_ff44627d34d063ab[] = {0, 1, 2}; +static const uint16_t i_ff44627d34d063ab[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_ff44627d34d063ab = { + 0xff44627d34d063ab, b_ff44627d34d063ab.words, 63, nullptr, m_ff44627d34d063ab, + 0, 3, i_ff44627d34d063ab, nullptr, nullptr, { &s_ff44627d34d063ab, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE +static const ::capnp::_::AlignedData<55> b_8de04c65deeb1510 = { + { 0, 0, 0, 0, 5, 0, 6, 0, + 16, 21, 235, 222, 101, 76, 224, 141, + 18, 0, 0, 0, 1, 0, 0, 0, + 127, 216, 135, 181, 36, 146, 125, 181, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 26, 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, 82, 101, 115, 116, 67, 97, + 112, 97, 98, 105, 108, 105, 116, 105, + 101, 115, 0, 0, 0, 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, 178, 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, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 53, 0, 0, 0, 34, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 3, 0, 1, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 100, 101, 112, 108, 111, 121, 101, 100, + 84, 105, 108, 101, 68, 66, 86, 101, + 114, 115, 105, 111, 110, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 171, 99, 208, 52, 125, 98, 68, 255, + 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, + 109, 105, 110, 105, 109, 117, 109, 83, + 117, 112, 112, 111, 114, 116, 101, 100, + 84, 105, 108, 101, 68, 66, 67, 108, + 105, 101, 110, 116, 86, 101, 114, 115, + 105, 111, 110, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 171, 99, 208, 52, 125, 98, 68, 255, + 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, } +}; +::capnp::word const* const bp_8de04c65deeb1510 = b_8de04c65deeb1510.words; +#if !CAPNP_LITE +static const ::capnp::_::RawSchema* const d_8de04c65deeb1510[] = { + &s_ff44627d34d063ab, +}; +static const uint16_t m_8de04c65deeb1510[] = {0, 1}; +static const uint16_t i_8de04c65deeb1510[] = {0, 1}; +const ::capnp::_::RawSchema s_8de04c65deeb1510 = { + 0x8de04c65deeb1510, b_8de04c65deeb1510.words, 55, d_8de04c65deeb1510, m_8de04c65deeb1510, + 1, 2, i_8de04c65deeb1510, nullptr, nullptr, { &s_8de04c65deeb1510, nullptr, nullptr, 0, 0, nullptr }, false +}; +#endif // !CAPNP_LITE } // namespace schemas } // namespace capnp @@ -11823,6 +11966,30 @@ constexpr ::capnp::_::RawSchema const* ObjectInfoResponse::_capnpPrivate::schema #endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL #endif // !CAPNP_LITE +// TileDBVersion +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t TileDBVersion::_capnpPrivate::dataWordSize; +constexpr uint16_t TileDBVersion::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind TileDBVersion::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* TileDBVersion::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + +// RestCapabilities +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr uint16_t RestCapabilities::_capnpPrivate::dataWordSize; +constexpr uint16_t RestCapabilities::_capnpPrivate::pointerCount; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#if !CAPNP_LITE +#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +constexpr ::capnp::Kind RestCapabilities::_capnpPrivate::kind; +constexpr ::capnp::_::RawSchema const* RestCapabilities::_capnpPrivate::schema; +#endif // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL +#endif // !CAPNP_LITE + } // namespace } // namespace diff --git a/tiledb/sm/serialization/tiledb-rest.capnp.h b/tiledb/sm/serialization/tiledb-rest.capnp.h index 011410d65e7..1e12ed98719 100644 --- a/tiledb/sm/serialization/tiledb-rest.capnp.h +++ b/tiledb/sm/serialization/tiledb-rest.capnp.h @@ -124,6 +124,8 @@ enum class ObjectType_f3bb391da5271019 : uint16_t { }; CAPNP_DECLARE_ENUM(ObjectType, f3bb391da5271019); CAPNP_DECLARE_SCHEMA(87f0466598bb29be); +CAPNP_DECLARE_SCHEMA(ff44627d34d063ab); +CAPNP_DECLARE_SCHEMA(8de04c65deeb1510); } // namespace schemas } // namespace capnp @@ -1878,6 +1880,40 @@ struct ObjectInfoResponse { }; }; +struct TileDBVersion { + TileDBVersion() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(ff44627d34d063ab, 1, 0) +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE + }; +}; + +struct RestCapabilities { + RestCapabilities() = delete; + + class Reader; + class Builder; + class Pipeline; + + struct _capnpPrivate { + CAPNP_DECLARE_STRUCT_HEADER(8de04c65deeb1510, 0, 2) +#if !CAPNP_LITE + static constexpr ::capnp::_::RawBrandedSchema const* brand() { + return &schema->defaultBrand; + } +#endif // !CAPNP_LITE + }; +}; + // ======================================================================================= class DomainArray::Reader { @@ -16400,6 +16436,234 @@ class ObjectInfoResponse::Pipeline { }; #endif // !CAPNP_LITE +class TileDBVersion::Reader { + public: + typedef TileDBVersion 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 ::uint16_t getMajor() const; + + inline ::uint16_t getMinor() const; + + inline ::uint16_t getPatch() 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 TileDBVersion::Builder { + public: + typedef TileDBVersion 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 ::uint16_t getMajor(); + inline void setMajor(::uint16_t value); + + inline ::uint16_t getMinor(); + inline void setMinor(::uint16_t value); + + inline ::uint16_t getPatch(); + inline void setPatch(::uint16_t value); + + private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class TileDBVersion::Pipeline { + public: + typedef TileDBVersion 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 RestCapabilities::Reader { + public: + typedef RestCapabilities 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 bool hasDeployedTileDBVersion() const; + inline ::tiledb::sm::serialization::capnp::TileDBVersion::Reader + getDeployedTileDBVersion() const; + + inline bool hasMinimumSupportedTileDBClientVersion() const; + inline ::tiledb::sm::serialization::capnp::TileDBVersion::Reader + getMinimumSupportedTileDBClientVersion() 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 RestCapabilities::Builder { + public: + typedef RestCapabilities 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 bool hasDeployedTileDBVersion(); + inline ::tiledb::sm::serialization::capnp::TileDBVersion::Builder + getDeployedTileDBVersion(); + inline void setDeployedTileDBVersion( + ::tiledb::sm::serialization::capnp::TileDBVersion::Reader value); + inline ::tiledb::sm::serialization::capnp::TileDBVersion::Builder + initDeployedTileDBVersion(); + inline void adoptDeployedTileDBVersion( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::TileDBVersion>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::TileDBVersion> + disownDeployedTileDBVersion(); + + inline bool hasMinimumSupportedTileDBClientVersion(); + inline ::tiledb::sm::serialization::capnp::TileDBVersion::Builder + getMinimumSupportedTileDBClientVersion(); + inline void setMinimumSupportedTileDBClientVersion( + ::tiledb::sm::serialization::capnp::TileDBVersion::Reader value); + inline ::tiledb::sm::serialization::capnp::TileDBVersion::Builder + initMinimumSupportedTileDBClientVersion(); + inline void adoptMinimumSupportedTileDBClientVersion( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::TileDBVersion>&& + value); + inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::TileDBVersion> + disownMinimumSupportedTileDBClientVersion(); + + private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + template + friend struct ::capnp::_::PointerHelpers; +}; + +#if !CAPNP_LITE +class RestCapabilities::Pipeline { + public: + typedef RestCapabilities Pipelines; + + inline Pipeline(decltype(nullptr)) + : _typeless(nullptr) { + } + inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) { + } + + inline ::tiledb::sm::serialization::capnp::TileDBVersion::Pipeline + getDeployedTileDBVersion(); + inline ::tiledb::sm::serialization::capnp::TileDBVersion::Pipeline + getMinimumSupportedTileDBClientVersion(); + + private: + ::capnp::AnyPointer::Pipeline _typeless; + friend class ::capnp::PipelineHook; + template + friend struct ::capnp::ToDynamic_; +}; +#endif // !CAPNP_LITE + // ======================================================================================= inline bool DomainArray::Reader::hasInt8() const { @@ -34682,6 +34946,160 @@ inline void ObjectInfoResponse::Builder::setObjectType( ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); } +inline ::uint16_t TileDBVersion::Reader::getMajor() const { + return _reader.getDataField<::uint16_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t TileDBVersion::Builder::getMajor() { + return _builder.getDataField<::uint16_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS); +} +inline void TileDBVersion::Builder::setMajor(::uint16_t value) { + _builder.setDataField<::uint16_t>( + ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); +} + +inline ::uint16_t TileDBVersion::Reader::getMinor() const { + return _reader.getDataField<::uint16_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t TileDBVersion::Builder::getMinor() { + return _builder.getDataField<::uint16_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS); +} +inline void TileDBVersion::Builder::setMinor(::uint16_t value) { + _builder.setDataField<::uint16_t>( + ::capnp::bounded<1>() * ::capnp::ELEMENTS, value); +} + +inline ::uint16_t TileDBVersion::Reader::getPatch() const { + return _reader.getDataField<::uint16_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} + +inline ::uint16_t TileDBVersion::Builder::getPatch() { + return _builder.getDataField<::uint16_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS); +} +inline void TileDBVersion::Builder::setPatch(::uint16_t value) { + _builder.setDataField<::uint16_t>( + ::capnp::bounded<2>() * ::capnp::ELEMENTS, value); +} + +inline bool RestCapabilities::Reader::hasDeployedTileDBVersion() const { + return !_reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline bool RestCapabilities::Builder::hasDeployedTileDBVersion() { + return !_builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS) + .isNull(); +} +inline ::tiledb::sm::serialization::capnp::TileDBVersion::Reader +RestCapabilities::Reader::getDeployedTileDBVersion() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::TileDBVersion>::get( + _reader.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::TileDBVersion::Builder +RestCapabilities::Builder::getDeployedTileDBVersion() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::TileDBVersion>::get( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::TileDBVersion::Pipeline +RestCapabilities::Pipeline::getDeployedTileDBVersion() { + return ::tiledb::sm::serialization::capnp::TileDBVersion::Pipeline( + _typeless.getPointerField(0)); +} +#endif // !CAPNP_LITE +inline void RestCapabilities::Builder::setDeployedTileDBVersion( + ::tiledb::sm::serialization::capnp::TileDBVersion::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::TileDBVersion>::set( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + value); +} +inline ::tiledb::sm::serialization::capnp::TileDBVersion::Builder +RestCapabilities::Builder::initDeployedTileDBVersion() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::TileDBVersion>::init( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} +inline void RestCapabilities::Builder::adoptDeployedTileDBVersion( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::TileDBVersion>&& + value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::TileDBVersion>::adopt( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::TileDBVersion> +RestCapabilities::Builder::disownDeployedTileDBVersion() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::TileDBVersion>::disown( + _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS)); +} + +inline bool RestCapabilities::Reader::hasMinimumSupportedTileDBClientVersion() + const { + return !_reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline bool +RestCapabilities::Builder::hasMinimumSupportedTileDBClientVersion() { + return !_builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS) + .isNull(); +} +inline ::tiledb::sm::serialization::capnp::TileDBVersion::Reader +RestCapabilities::Reader::getMinimumSupportedTileDBClientVersion() const { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::TileDBVersion>::get( + _reader.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline ::tiledb::sm::serialization::capnp::TileDBVersion::Builder +RestCapabilities::Builder::getMinimumSupportedTileDBClientVersion() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::TileDBVersion>::get( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +#if !CAPNP_LITE +inline ::tiledb::sm::serialization::capnp::TileDBVersion::Pipeline +RestCapabilities::Pipeline::getMinimumSupportedTileDBClientVersion() { + return ::tiledb::sm::serialization::capnp::TileDBVersion::Pipeline( + _typeless.getPointerField(1)); +} +#endif // !CAPNP_LITE +inline void RestCapabilities::Builder::setMinimumSupportedTileDBClientVersion( + ::tiledb::sm::serialization::capnp::TileDBVersion::Reader value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::TileDBVersion>::set( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + value); +} +inline ::tiledb::sm::serialization::capnp::TileDBVersion::Builder +RestCapabilities::Builder::initMinimumSupportedTileDBClientVersion() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::TileDBVersion>::init( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} +inline void RestCapabilities::Builder::adoptMinimumSupportedTileDBClientVersion( + ::capnp::Orphan<::tiledb::sm::serialization::capnp::TileDBVersion>&& + value) { + ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::TileDBVersion>::adopt( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS), + kj::mv(value)); +} +inline ::capnp::Orphan<::tiledb::sm::serialization::capnp::TileDBVersion> +RestCapabilities::Builder::disownMinimumSupportedTileDBClientVersion() { + return ::capnp::_:: + PointerHelpers<::tiledb::sm::serialization::capnp::TileDBVersion>::disown( + _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS)); +} + } // namespace capnp } // namespace serialization } // namespace sm