diff --git a/tiledb/api/c_api/attribute/attribute_api.cc b/tiledb/api/c_api/attribute/attribute_api.cc index 9d9efdde613..62d434c3297 100644 --- a/tiledb/api/c_api/attribute/attribute_api.cc +++ b/tiledb/api/c_api/attribute/attribute_api.cc @@ -205,150 +205,167 @@ capi_return_t tiledb_attribute_get_enumeration_name( using tiledb::api::api_entry_context; -int32_t tiledb_attribute_alloc( +CAPI_INTERFACE( + attribute_alloc, tiledb_ctx_t* ctx, const char* name, tiledb_datatype_t type, - tiledb_attribute_handle_t** attr) noexcept { + tiledb_attribute_handle_t** attr) { return api_entry_context( ctx, name, type, attr); } -void tiledb_attribute_free(tiledb_attribute_handle_t** attr) noexcept { +CAPI_INTERFACE_VOID(attribute_free, tiledb_attribute_handle_t** attr) { return tiledb::api::api_entry_void(attr); } -int32_t tiledb_attribute_set_nullable( +CAPI_INTERFACE( + attribute_set_nullable, tiledb_ctx_t* ctx, tiledb_attribute_handle_t* attr, - uint8_t nullable) noexcept { + uint8_t nullable) { return api_entry_context( ctx, attr, nullable); } -int32_t tiledb_attribute_set_filter_list( +CAPI_INTERFACE( + attribute_set_filter_list, tiledb_ctx_t* ctx, tiledb_attribute_handle_t* attr, - tiledb_filter_list_t* filter_list) noexcept { + tiledb_filter_list_t* filter_list) { return api_entry_context( ctx, attr, filter_list); } -int32_t tiledb_attribute_set_cell_val_num( +CAPI_INTERFACE( + attribute_set_cell_val_num, tiledb_ctx_t* ctx, tiledb_attribute_handle_t* attr, - uint32_t cell_val_num) noexcept { + uint32_t cell_val_num) { return api_entry_context( ctx, attr, cell_val_num); } -int32_t tiledb_attribute_get_name( +CAPI_INTERFACE( + attribute_get_name, tiledb_ctx_t* ctx, const tiledb_attribute_handle_t* attr, - const char** name) noexcept { + const char** name) { return api_entry_context( ctx, attr, name); } -int32_t tiledb_attribute_get_type( +CAPI_INTERFACE( + attribute_get_type, tiledb_ctx_t* ctx, const tiledb_attribute_handle_t* attr, - tiledb_datatype_t* type) noexcept { + tiledb_datatype_t* type) { return api_entry_context( ctx, attr, type); } -int32_t tiledb_attribute_get_nullable( +CAPI_INTERFACE( + attribute_get_nullable, tiledb_ctx_t* ctx, tiledb_attribute_handle_t* attr, - uint8_t* nullable) noexcept { + uint8_t* nullable) { return api_entry_context( ctx, attr, nullable); } -int32_t tiledb_attribute_get_filter_list( +CAPI_INTERFACE( + attribute_get_filter_list, tiledb_ctx_t* ctx, tiledb_attribute_handle_t* attr, - tiledb_filter_list_t** filter_list) noexcept { + tiledb_filter_list_t** filter_list) { return api_entry_context( ctx, attr, filter_list); } -int32_t tiledb_attribute_get_cell_val_num( +CAPI_INTERFACE( + attribute_get_cell_val_num, tiledb_ctx_t* ctx, const tiledb_attribute_handle_t* attr, - uint32_t* cell_val_num) noexcept { + uint32_t* cell_val_num) { return api_entry_context( ctx, attr, cell_val_num); } -int32_t tiledb_attribute_get_cell_size( +CAPI_INTERFACE( + attribute_get_cell_size, tiledb_ctx_t* ctx, const tiledb_attribute_handle_t* attr, - uint64_t* cell_size) noexcept { + uint64_t* cell_size) { return api_entry_context( ctx, attr, cell_size); } -int32_t tiledb_attribute_dump( +CAPI_INTERFACE( + attribute_dump, tiledb_ctx_t* ctx, const tiledb_attribute_handle_t* attr, - FILE* out) noexcept { + FILE* out) { return api_entry_context(ctx, attr, out); } -int32_t tiledb_attribute_set_fill_value( +CAPI_INTERFACE( + attribute_set_fill_value, tiledb_ctx_t* ctx, tiledb_attribute_handle_t* attr, const void* value, - uint64_t size) noexcept { + uint64_t size) { return api_entry_context( ctx, attr, value, size); } -int32_t tiledb_attribute_get_fill_value( +CAPI_INTERFACE( + attribute_get_fill_value, tiledb_ctx_t* ctx, tiledb_attribute_handle_t* attr, const void** value, - uint64_t* size) noexcept { + uint64_t* size) { return api_entry_context( ctx, attr, value, size); } -int32_t tiledb_attribute_set_fill_value_nullable( +CAPI_INTERFACE( + attribute_set_fill_value_nullable, tiledb_ctx_t* ctx, tiledb_attribute_handle_t* attr, const void* value, uint64_t size, - uint8_t valid) noexcept { + uint8_t valid) { return api_entry_context< tiledb::api::tiledb_attribute_set_fill_value_nullable>( ctx, attr, value, size, valid); } -int32_t tiledb_attribute_get_fill_value_nullable( +CAPI_INTERFACE( + attribute_get_fill_value_nullable, tiledb_ctx_t* ctx, tiledb_attribute_handle_t* attr, const void** value, uint64_t* size, - uint8_t* valid) noexcept { + uint8_t* valid) { return api_entry_context< tiledb::api::tiledb_attribute_get_fill_value_nullable>( ctx, attr, value, size, valid); } -capi_return_t tiledb_attribute_set_enumeration_name( +CAPI_INTERFACE( + attribute_set_enumeration_name, tiledb_ctx_t* ctx, tiledb_attribute_t* attr, - const char* enumeration_name) noexcept { + const char* enumeration_name) { return api_entry_context( ctx, attr, enumeration_name); } -capi_return_t tiledb_attribute_get_enumeration_name( +CAPI_INTERFACE( + attribute_get_enumeration_name, tiledb_ctx_t* ctx, tiledb_attribute_t* attr, - tiledb_string_t** name) noexcept { + tiledb_string_t** name) { return api_entry_context( ctx, attr, name); } diff --git a/tiledb/api/c_api/buffer/buffer_api.cc b/tiledb/api/c_api/buffer/buffer_api.cc index 335441c8f6d..6b6a28de7de 100644 --- a/tiledb/api/c_api/buffer/buffer_api.cc +++ b/tiledb/api/c_api/buffer/buffer_api.cc @@ -98,45 +98,48 @@ capi_return_t tiledb_buffer_set_data( using tiledb::api::api_entry_context; using tiledb::api::api_entry_void; -capi_return_t tiledb_buffer_alloc( - tiledb_ctx_t* ctx, tiledb_buffer_t** buffer) noexcept { +CAPI_INTERFACE(buffer_alloc, tiledb_ctx_t* ctx, tiledb_buffer_t** buffer) { return api_entry_context(ctx, buffer); } -void tiledb_buffer_free(tiledb_buffer_t** buffer) noexcept { +CAPI_INTERFACE_VOID(buffer_free, tiledb_buffer_t** buffer) { return api_entry_void(buffer); } -capi_return_t tiledb_buffer_set_type( +CAPI_INTERFACE( + buffer_set_type, tiledb_ctx_t* ctx, tiledb_buffer_t* buffer, - tiledb_datatype_t datatype) noexcept { + tiledb_datatype_t datatype) { return api_entry_context( ctx, buffer, datatype); } -capi_return_t tiledb_buffer_get_type( +CAPI_INTERFACE( + buffer_get_type, tiledb_ctx_t* ctx, const tiledb_buffer_t* buffer, - tiledb_datatype_t* datatype) noexcept { + tiledb_datatype_t* datatype) { return api_entry_context( ctx, buffer, datatype); } -capi_return_t tiledb_buffer_get_data( +CAPI_INTERFACE( + buffer_get_data, tiledb_ctx_t* ctx, const tiledb_buffer_t* buffer, void** data, - uint64_t* size) noexcept { + uint64_t* size) { return api_entry_context( ctx, buffer, data, size); } -capi_return_t tiledb_buffer_set_data( +CAPI_INTERFACE( + buffer_set_data, tiledb_ctx_t* ctx, tiledb_buffer_t* buffer, void* data, - uint64_t size) noexcept { + uint64_t size) { return api_entry_context( ctx, buffer, data, size); } diff --git a/tiledb/api/c_api/buffer_list/buffer_list_api.cc b/tiledb/api/c_api/buffer_list/buffer_list_api.cc index 7b19a77db3e..6e7fdfa93a7 100644 --- a/tiledb/api/c_api/buffer_list/buffer_list_api.cc +++ b/tiledb/api/c_api/buffer_list/buffer_list_api.cc @@ -121,45 +121,49 @@ capi_return_t tiledb_buffer_list_flatten( using tiledb::api::api_entry_context; using tiledb::api::api_entry_void; -capi_return_t tiledb_buffer_list_alloc( - tiledb_ctx_t* ctx, tiledb_buffer_list_t** buffer_list) noexcept { +CAPI_INTERFACE( + buffer_list_alloc, tiledb_ctx_t* ctx, tiledb_buffer_list_t** buffer_list) { return api_entry_context( ctx, buffer_list); } -void tiledb_buffer_list_free(tiledb_buffer_list_t** buffer_list) noexcept { +CAPI_INTERFACE_VOID(buffer_list_free, tiledb_buffer_list_t** buffer_list) { return api_entry_void(buffer_list); } -capi_return_t tiledb_buffer_list_get_num_buffers( +CAPI_INTERFACE( + buffer_list_get_num_buffers, tiledb_ctx_t* ctx, const tiledb_buffer_list_t* buffer_list, - uint64_t* num_buffers) noexcept { + uint64_t* num_buffers) { return api_entry_context( ctx, buffer_list, num_buffers); } -capi_return_t tiledb_buffer_list_get_buffer( +CAPI_INTERFACE( + buffer_list_get_buffer, tiledb_ctx_t* ctx, const tiledb_buffer_list_t* buffer_list, uint64_t buffer_idx, - tiledb_buffer_t** buffer) noexcept { + tiledb_buffer_t** buffer) { return api_entry_context( ctx, buffer_list, buffer_idx, buffer); } -capi_return_t tiledb_buffer_list_get_total_size( +CAPI_INTERFACE( + buffer_list_get_total_size, tiledb_ctx_t* ctx, const tiledb_buffer_list_t* buffer_list, - uint64_t* total_size) noexcept { + uint64_t* total_size) { return api_entry_context( ctx, buffer_list, total_size); } -capi_return_t tiledb_buffer_list_flatten( +CAPI_INTERFACE( + buffer_list_flatten, tiledb_ctx_t* ctx, tiledb_buffer_list_t* buffer_list, - tiledb_buffer_t** buffer) noexcept { + tiledb_buffer_t** buffer) { return api_entry_context( ctx, buffer_list, buffer); } diff --git a/tiledb/api/c_api/data_order/data_order_api.cc b/tiledb/api/c_api/data_order/data_order_api.cc index 9b8888c2edc..815e931b22e 100644 --- a/tiledb/api/c_api/data_order/data_order_api.cc +++ b/tiledb/api/c_api/data_order/data_order_api.cc @@ -55,14 +55,14 @@ capi_return_t tiledb_data_order_from_str( using tiledb::api::api_entry_plain; -capi_return_t tiledb_data_order_to_str( - tiledb_data_order_t data_order, const char** str) noexcept { +CAPI_INTERFACE( + data_order_to_str, tiledb_data_order_t data_order, const char** str) { return api_entry_plain( data_order, str); } -capi_return_t tiledb_data_order_from_str( - const char* str, tiledb_data_order_t* data_order) noexcept { +CAPI_INTERFACE( + data_order_from_str, const char* str, tiledb_data_order_t* data_order) { return api_entry_plain( str, data_order); } diff --git a/tiledb/api/c_api/datatype/datatype_api.cc b/tiledb/api/c_api/datatype/datatype_api.cc index 21a213fc67e..854b49fe2a5 100644 --- a/tiledb/api/c_api/datatype/datatype_api.cc +++ b/tiledb/api/c_api/datatype/datatype_api.cc @@ -61,13 +61,12 @@ uint64_t tiledb_datatype_size(tiledb_datatype_t type) { using tiledb::api::api_entry_plain; -capi_return_t tiledb_datatype_to_str( - tiledb_datatype_t datatype, const char** str) noexcept { +CAPI_INTERFACE(datatype_to_str, tiledb_datatype_t datatype, const char** str) { return api_entry_plain(datatype, str); } -capi_return_t tiledb_datatype_from_str( - const char* str, tiledb_datatype_t* datatype) noexcept { +CAPI_INTERFACE( + datatype_from_str, const char* str, tiledb_datatype_t* datatype) { return api_entry_plain(str, datatype); } diff --git a/tiledb/api/c_api/dimension/dimension_api.cc b/tiledb/api/c_api/dimension/dimension_api.cc index 594d14e3bdb..c8a831d7a04 100644 --- a/tiledb/api/c_api/dimension/dimension_api.cc +++ b/tiledb/api/c_api/dimension/dimension_api.cc @@ -141,86 +141,98 @@ int32_t tiledb_dimension_dump(const tiledb_dimension_t* dim, FILE* out) { using tiledb::api::api_entry_context; -int32_t tiledb_dimension_alloc( +CAPI_INTERFACE( + dimension_alloc, tiledb_ctx_t* ctx, const char* name, tiledb_datatype_t type, const void* dim_domain, const void* tile_extent, - tiledb_dimension_t** dim) noexcept { + tiledb_dimension_t** dim) { return api_entry_context( ctx, name, type, dim_domain, tile_extent, dim); } -void tiledb_dimension_free(tiledb_dimension_t** dim) noexcept { +CAPI_INTERFACE_VOID(dimension_free, tiledb_dimension_t** dim) { return tiledb::api::api_entry_void(dim); } -int32_t tiledb_dimension_set_filter_list( +CAPI_INTERFACE( + dimension_set_filter_list, tiledb_ctx_t* ctx, tiledb_dimension_t* dim, - tiledb_filter_list_t* filter_list) noexcept { + tiledb_filter_list_t* filter_list) { return api_entry_context( ctx, dim, filter_list); } -int32_t tiledb_dimension_set_cell_val_num( +CAPI_INTERFACE( + dimension_set_cell_val_num, tiledb_ctx_t* ctx, tiledb_dimension_t* dim, - uint32_t cell_val_num) noexcept { + uint32_t cell_val_num) { return api_entry_context( ctx, dim, cell_val_num); } -int32_t tiledb_dimension_get_filter_list( +CAPI_INTERFACE( + dimension_get_filter_list, tiledb_ctx_t* ctx, tiledb_dimension_t* dim, - tiledb_filter_list_t** filter_list) noexcept { + tiledb_filter_list_t** filter_list) { return api_entry_context( ctx, dim, filter_list); } -int32_t tiledb_dimension_get_cell_val_num( +CAPI_INTERFACE( + dimension_get_cell_val_num, tiledb_ctx_t* ctx, const tiledb_dimension_t* dim, - uint32_t* cell_val_num) noexcept { + uint32_t* cell_val_num) { return api_entry_context( ctx, dim, cell_val_num); } -int32_t tiledb_dimension_get_name( +CAPI_INTERFACE( + dimension_get_name, tiledb_ctx_t* ctx, const tiledb_dimension_t* dim, - const char** name) noexcept { + const char** name) { return api_entry_context( ctx, dim, name); } -int32_t tiledb_dimension_get_type( +CAPI_INTERFACE( + dimension_get_type, tiledb_ctx_t* ctx, const tiledb_dimension_t* dim, - tiledb_datatype_t* type) noexcept { + tiledb_datatype_t* type) { return api_entry_context( ctx, dim, type); } -int32_t tiledb_dimension_get_domain( +CAPI_INTERFACE( + dimension_get_domain, tiledb_ctx_t* ctx, const tiledb_dimension_t* dim, - const void** domain) noexcept { + const void** domain) { return api_entry_context( ctx, dim, domain); } -int32_t tiledb_dimension_get_tile_extent( +CAPI_INTERFACE( + dimension_get_tile_extent, tiledb_ctx_t* ctx, const tiledb_dimension_t* dim, - const void** tile_extent) noexcept { + const void** tile_extent) { return api_entry_context( ctx, dim, tile_extent); } -int32_t tiledb_dimension_dump( - tiledb_ctx_t* ctx, const tiledb_dimension_t* dim, FILE* out) noexcept { +CAPI_INTERFACE( + dimension_dump, + tiledb_ctx_t* ctx, + const tiledb_dimension_t* dim, + FILE* out) { return api_entry_context(ctx, dim, out); } diff --git a/tiledb/api/c_api/dimension_label/dimension_label_api.cc b/tiledb/api/c_api/dimension_label/dimension_label_api.cc index 1476596066b..41e348ef63b 100644 --- a/tiledb/api/c_api/dimension_label/dimension_label_api.cc +++ b/tiledb/api/c_api/dimension_label/dimension_label_api.cc @@ -105,66 +105,73 @@ capi_return_t tiledb_dimension_label_get_uri( using tiledb::api::api_entry_context; using tiledb::api::api_entry_void; -void tiledb_dimension_label_free( - tiledb_dimension_label_t** dim_label) noexcept { +CAPI_INTERFACE_VOID( + dimension_label_free, tiledb_dimension_label_t** dim_label) { return api_entry_void(dim_label); } -capi_return_t tiledb_dimension_label_get_dimension_index( +CAPI_INTERFACE( + dimension_label_get_dimension_index, tiledb_ctx_t* ctx, tiledb_dimension_label_t* dim_label, - uint32_t* dim_index) noexcept { + uint32_t* dim_index) { return api_entry_context< tiledb::api::tiledb_dimension_label_get_dimension_index>( ctx, dim_label, dim_index); } -capi_return_t tiledb_dimension_label_get_label_attr_name( +CAPI_INTERFACE( + dimension_label_get_label_attr_name, tiledb_ctx_t* ctx, tiledb_dimension_label_t* dim_label, - const char** label_attr_name) noexcept { + const char** label_attr_name) { return api_entry_context< tiledb::api::tiledb_dimension_label_get_label_attr_name>( ctx, dim_label, label_attr_name); } -capi_return_t tiledb_dimension_label_get_label_cell_val_num( +CAPI_INTERFACE( + dimension_label_get_label_cell_val_num, tiledb_ctx_t* ctx, tiledb_dimension_label_t* dim_label, - uint32_t* label_cell_val_num) noexcept { + uint32_t* label_cell_val_num) { return api_entry_context< tiledb::api::tiledb_dimension_label_get_label_cell_val_num>( ctx, dim_label, label_cell_val_num); } -capi_return_t tiledb_dimension_label_get_label_order( +CAPI_INTERFACE( + dimension_label_get_label_order, tiledb_ctx_t* ctx, tiledb_dimension_label_t* dim_label, - tiledb_data_order_t* label_order) noexcept { + tiledb_data_order_t* label_order) { return api_entry_context( ctx, dim_label, label_order); } -capi_return_t tiledb_dimension_label_get_label_type( +CAPI_INTERFACE( + dimension_label_get_label_type, tiledb_ctx_t* ctx, tiledb_dimension_label_t* dim_label, - tiledb_datatype_t* label_type) noexcept { + tiledb_datatype_t* label_type) { return api_entry_context( ctx, dim_label, label_type); } -capi_return_t tiledb_dimension_label_get_name( +CAPI_INTERFACE( + dimension_label_get_name, tiledb_ctx_t* ctx, tiledb_dimension_label_t* dim_label, - const char** name) noexcept { + const char** name) { return api_entry_context( ctx, dim_label, name); } -capi_return_t tiledb_dimension_label_get_uri( +CAPI_INTERFACE( + dimension_label_get_uri, tiledb_ctx_t* ctx, tiledb_dimension_label_t* dim_label, - const char** uri) noexcept { + const char** uri) { return api_entry_context( ctx, dim_label, uri); } diff --git a/tiledb/api/c_api/domain/domain_api.cc b/tiledb/api/c_api/domain/domain_api.cc index f942e7e25f9..3a694a97c11 100644 --- a/tiledb/api/c_api/domain/domain_api.cc +++ b/tiledb/api/c_api/domain/domain_api.cc @@ -146,65 +146,72 @@ int32_t tiledb_domain_dump(const tiledb_domain_t* domain, FILE* out) { using tiledb::api::api_entry_context; -int32_t tiledb_domain_alloc( - tiledb_ctx_t* ctx, tiledb_domain_t** domain) noexcept { +CAPI_INTERFACE(domain_alloc, tiledb_ctx_t* ctx, tiledb_domain_t** domain) { return api_entry_context(ctx, domain); } -void tiledb_domain_free(tiledb_domain_t** domain) noexcept { +CAPI_INTERFACE_VOID(domain_free, tiledb_domain_t** domain) { return tiledb::api::api_entry_void(domain); } -int32_t tiledb_domain_get_type( +CAPI_INTERFACE( + domain_get_type, tiledb_ctx_t* ctx, const tiledb_domain_t* domain, - tiledb_datatype_t* type) noexcept { + tiledb_datatype_t* type) { return api_entry_context( ctx, domain, type); } -int32_t tiledb_domain_get_ndim( - tiledb_ctx_t* ctx, const tiledb_domain_t* domain, uint32_t* ndim) noexcept { +CAPI_INTERFACE( + domain_get_ndim, + tiledb_ctx_t* ctx, + const tiledb_domain_t* domain, + uint32_t* ndim) { return api_entry_context( ctx, domain, ndim); } -int32_t tiledb_domain_add_dimension( +CAPI_INTERFACE( + domain_add_dimension, tiledb_ctx_t* ctx, tiledb_domain_t* domain, - tiledb_dimension_t* dim) noexcept { + tiledb_dimension_t* dim) { return api_entry_context( ctx, domain, dim); } -int32_t tiledb_domain_get_dimension_from_index( +CAPI_INTERFACE( + domain_get_dimension_from_index, tiledb_ctx_t* ctx, const tiledb_domain_t* domain, uint32_t index, - tiledb_dimension_t** dim) noexcept { + tiledb_dimension_t** dim) { return api_entry_context( ctx, domain, index, dim); } -int32_t tiledb_domain_get_dimension_from_name( +CAPI_INTERFACE( + domain_get_dimension_from_name, tiledb_ctx_t* ctx, const tiledb_domain_t* domain, const char* name, - tiledb_dimension_t** dim) noexcept { + tiledb_dimension_t** dim) { return api_entry_context( ctx, domain, name, dim); } -int32_t tiledb_domain_has_dimension( +CAPI_INTERFACE( + domain_has_dimension, tiledb_ctx_t* ctx, const tiledb_domain_t* domain, const char* name, - int32_t* has_dim) noexcept { + int32_t* has_dim) { return api_entry_context( ctx, domain, name, has_dim); } -int32_t tiledb_domain_dump( - tiledb_ctx_t* ctx, const tiledb_domain_t* domain, FILE* out) noexcept { +CAPI_INTERFACE( + domain_dump, tiledb_ctx_t* ctx, const tiledb_domain_t* domain, FILE* out) { return api_entry_context(ctx, domain, out); } diff --git a/tiledb/api/c_api/enumeration/enumeration_api.cc b/tiledb/api/c_api/enumeration/enumeration_api.cc index 73283621af2..d73759bef31 100644 --- a/tiledb/api/c_api/enumeration/enumeration_api.cc +++ b/tiledb/api/c_api/enumeration/enumeration_api.cc @@ -179,7 +179,8 @@ capi_return_t tiledb_enumeration_dump( using tiledb::api::api_entry_context; using tiledb::api::api_entry_void; -capi_return_t tiledb_enumeration_alloc( +CAPI_INTERFACE( + enumeration_alloc, tiledb_ctx_t* ctx, const char* name, tiledb_datatype_t type, @@ -189,7 +190,7 @@ capi_return_t tiledb_enumeration_alloc( uint64_t data_size, const void* offsets, uint64_t offsets_size, - tiledb_enumeration_t** enumeration) noexcept { + tiledb_enumeration_t** enumeration) { return api_entry_context( ctx, name, @@ -203,14 +204,15 @@ capi_return_t tiledb_enumeration_alloc( enumeration); } -capi_return_t tiledb_enumeration_extend( +CAPI_INTERFACE( + enumeration_extend, tiledb_ctx_t* ctx, tiledb_enumeration_t* old_enumeration, const void* data, uint64_t data_size, const void* offsets, uint64_t offsets_size, - tiledb_enumeration_t** new_enumeration) noexcept { + tiledb_enumeration_t** new_enumeration) { return api_entry_context( ctx, old_enumeration, @@ -221,62 +223,71 @@ capi_return_t tiledb_enumeration_extend( new_enumeration); } -void tiledb_enumeration_free(tiledb_enumeration_t** enumeration) noexcept { +CAPI_INTERFACE_VOID(enumeration_free, tiledb_enumeration_t** enumeration) { return api_entry_void(enumeration); } -capi_return_t tiledb_enumeration_get_name( +CAPI_INTERFACE( + enumeration_get_name, tiledb_ctx_t* ctx, tiledb_enumeration_t* enumeration, - tiledb_string_t** name) noexcept { + tiledb_string_t** name) { return api_entry_context( ctx, enumeration, name); } -capi_return_t tiledb_enumeration_get_type( +CAPI_INTERFACE( + enumeration_get_type, tiledb_ctx_t* ctx, tiledb_enumeration_t* enumeration, - tiledb_datatype_t* type) noexcept { + tiledb_datatype_t* type) { return api_entry_context( ctx, enumeration, type); } -capi_return_t tiledb_enumeration_get_cell_val_num( +CAPI_INTERFACE( + enumeration_get_cell_val_num, tiledb_ctx_t* ctx, tiledb_enumeration_t* enumeration, - uint32_t* cell_val_num) noexcept { + uint32_t* cell_val_num) { return api_entry_context( ctx, enumeration, cell_val_num); } -capi_return_t tiledb_enumeration_get_ordered( +CAPI_INTERFACE( + enumeration_get_ordered, tiledb_ctx_t* ctx, tiledb_enumeration_t* enumeration, - int* ordered) noexcept { + int* ordered) { return api_entry_context( ctx, enumeration, ordered); } -capi_return_t tiledb_enumeration_get_data( +CAPI_INTERFACE( + enumeration_get_data, tiledb_ctx_t* ctx, tiledb_enumeration_t* enumeration, const void** data, - uint64_t* data_size) noexcept { + uint64_t* data_size) { return api_entry_context( ctx, enumeration, data, data_size); } -capi_return_t tiledb_enumeration_get_offsets( +CAPI_INTERFACE( + enumeration_get_offsets, tiledb_ctx_t* ctx, tiledb_enumeration_t* enumeration, const void** offsets, - uint64_t* offsets_size) noexcept { + uint64_t* offsets_size) { return api_entry_context( ctx, enumeration, offsets, offsets_size); } -capi_return_t tiledb_enumeration_dump( - tiledb_ctx_t* ctx, tiledb_enumeration_t* enumeration, FILE* out) noexcept { +CAPI_INTERFACE( + enumeration_dump, + tiledb_ctx_t* ctx, + tiledb_enumeration_t* enumeration, + FILE* out) { return api_entry_context( ctx, enumeration, out); } diff --git a/tiledb/api/c_api/filesystem/filesystem_api.cc b/tiledb/api/c_api/filesystem/filesystem_api.cc index 932f3316037..2fab52108d1 100644 --- a/tiledb/api/c_api/filesystem/filesystem_api.cc +++ b/tiledb/api/c_api/filesystem/filesystem_api.cc @@ -58,14 +58,14 @@ capi_return_t tiledb_filesystem_from_str( using tiledb::api::api_entry_plain; -capi_return_t tiledb_filesystem_to_str( - tiledb_filesystem_t filesystem, const char** str) noexcept { +CAPI_INTERFACE( + filesystem_to_str, tiledb_filesystem_t filesystem, const char** str) { return api_entry_plain( filesystem, str); } -capi_return_t tiledb_filesystem_from_str( - const char* str, tiledb_filesystem_t* filesystem) noexcept { +CAPI_INTERFACE( + filesystem_from_str, const char* str, tiledb_filesystem_t* filesystem) { return api_entry_plain( str, filesystem); } diff --git a/tiledb/api/c_api/filter/filter_api.cc b/tiledb/api/c_api/filter/filter_api.cc index 33c4179acf2..392e1ffb2bb 100644 --- a/tiledb/api/c_api/filter/filter_api.cc +++ b/tiledb/api/c_api/filter/filter_api.cc @@ -122,64 +122,72 @@ capi_return_t tiledb_filter_option_from_str( using tiledb::api::api_entry_context; using tiledb::api::api_entry_plain; -capi_return_t tiledb_filter_alloc( +CAPI_INTERFACE( + filter_alloc, tiledb_ctx_t* ctx, tiledb_filter_type_t type, - tiledb_filter_t** filter) noexcept { + tiledb_filter_t** filter) { return tiledb::api::api_entry_with_context( ctx, type, filter); } -void tiledb_filter_free(tiledb_filter_t** filter) noexcept { +CAPI_INTERFACE_VOID(filter_free, tiledb_filter_t** filter) { return tiledb::api::api_entry_void(filter); } -capi_return_t tiledb_filter_get_type( +CAPI_INTERFACE( + filter_get_type, tiledb_ctx_t* ctx, tiledb_filter_t* filter, - tiledb_filter_type_t* type) noexcept { + tiledb_filter_type_t* type) { return api_entry_context( ctx, filter, type); } -capi_return_t tiledb_filter_set_option( +CAPI_INTERFACE( + filter_set_option, tiledb_ctx_t* ctx, tiledb_filter_t* filter, tiledb_filter_option_t option, - const void* value) noexcept { + const void* value) { return api_entry_context( ctx, filter, option, value); } -capi_return_t tiledb_filter_get_option( +CAPI_INTERFACE( + filter_get_option, tiledb_ctx_t* ctx, tiledb_filter_t* filter, tiledb_filter_option_t option, - void* value) noexcept { + void* value) { return api_entry_context( ctx, filter, option, value); } -capi_return_t tiledb_filter_type_to_str( - tiledb_filter_type_t filter_type, const char** str) noexcept { +CAPI_INTERFACE( + filter_type_to_str, tiledb_filter_type_t filter_type, const char** str) { return api_entry_plain( filter_type, str); } -capi_return_t tiledb_filter_type_from_str( - const char* str, tiledb_filter_type_t* filter_type) noexcept { +CAPI_INTERFACE( + filter_type_from_str, const char* str, tiledb_filter_type_t* filter_type) { return api_entry_plain( str, filter_type); } -capi_return_t tiledb_filter_option_to_str( - tiledb_filter_option_t filter_option, const char** str) noexcept { +CAPI_INTERFACE( + filter_option_to_str, + tiledb_filter_option_t filter_option, + const char** str) { return api_entry_plain( filter_option, str); } -capi_return_t tiledb_filter_option_from_str( - const char* str, tiledb_filter_option_t* filter_option) noexcept { +CAPI_INTERFACE( + filter_option_from_str, + const char* str, + tiledb_filter_option_t* filter_option) { return api_entry_plain( str, filter_option); } diff --git a/tiledb/api/c_api/filter_list/filter_list_api.cc b/tiledb/api/c_api/filter_list/filter_list_api.cc index 3eb65a00623..3340059a295 100644 --- a/tiledb/api/c_api/filter_list/filter_list_api.cc +++ b/tiledb/api/c_api/filter_list/filter_list_api.cc @@ -108,55 +108,60 @@ capi_return_t tiledb_filter_list_get_max_chunk_size( using tiledb::api::api_entry_context; -capi_return_t tiledb_filter_list_alloc( - tiledb_ctx_t* ctx, tiledb_filter_list_t** filter_list) noexcept { +CAPI_INTERFACE( + filter_list_alloc, tiledb_ctx_t* ctx, tiledb_filter_list_t** filter_list) { return tiledb::api::api_entry_with_context< tiledb::api::tiledb_filter_list_alloc>(ctx, filter_list); } -void tiledb_filter_list_free(tiledb_filter_list_t** filter_list) noexcept { +CAPI_INTERFACE_VOID(filter_list_free, tiledb_filter_list_t** filter_list) { return tiledb::api::api_entry_void( filter_list); } -capi_return_t tiledb_filter_list_add_filter( +CAPI_INTERFACE( + filter_list_add_filter, tiledb_ctx_t* ctx, tiledb_filter_list_t* filter_list, - tiledb_filter_t* filter) noexcept { + tiledb_filter_t* filter) { return api_entry_context( ctx, filter_list, filter); } -capi_return_t tiledb_filter_list_set_max_chunk_size( +CAPI_INTERFACE( + filter_list_set_max_chunk_size, tiledb_ctx_t* ctx, tiledb_filter_list_t* filter_list, - uint32_t max_chunk_size) noexcept { + uint32_t max_chunk_size) { return api_entry_context( ctx, filter_list, max_chunk_size); } -capi_return_t tiledb_filter_list_get_nfilters( +CAPI_INTERFACE( + filter_list_get_nfilters, tiledb_ctx_t* ctx, const tiledb_filter_list_t* filter_list, - uint32_t* nfilters) noexcept { + uint32_t* nfilters) { return api_entry_context( ctx, filter_list, nfilters); } -capi_return_t tiledb_filter_list_get_filter_from_index( +CAPI_INTERFACE( + filter_list_get_filter_from_index, tiledb_ctx_t* ctx, const tiledb_filter_list_t* filter_list, uint32_t index, - tiledb_filter_t** filter) noexcept { + tiledb_filter_t** filter) { return api_entry_context< tiledb::api::tiledb_filter_list_get_filter_from_index>( ctx, filter_list, index, filter); } -capi_return_t tiledb_filter_list_get_max_chunk_size( +CAPI_INTERFACE( + filter_list_get_max_chunk_size, tiledb_ctx_t* ctx, const tiledb_filter_list_t* filter_list, - uint32_t* max_chunk_size) noexcept { + uint32_t* max_chunk_size) { return api_entry_context( ctx, filter_list, max_chunk_size); } diff --git a/tiledb/api/c_api/group/group_api.cc b/tiledb/api/c_api/group/group_api.cc index e5a195ad3eb..bf7b17ff219 100644 --- a/tiledb/api/c_api/group/group_api.cc +++ b/tiledb/api/c_api/group/group_api.cc @@ -549,95 +549,109 @@ using tiledb::api::api_entry_context; using tiledb::api::api_entry_void; using tiledb::api::api_entry_with_context; -capi_return_t tiledb_group_create( - tiledb_ctx_t* ctx, const char* group_uri) noexcept { +CAPI_INTERFACE(group_create, tiledb_ctx_t* ctx, const char* group_uri) { return api_entry_with_context( ctx, group_uri); } -capi_return_t tiledb_group_alloc( - tiledb_ctx_t* ctx, const char* group_uri, tiledb_group_t** group) noexcept { +CAPI_INTERFACE( + group_alloc, + tiledb_ctx_t* ctx, + const char* group_uri, + tiledb_group_t** group) { return api_entry_with_context( ctx, group_uri, group); } -capi_return_t tiledb_group_open( +CAPI_INTERFACE( + group_open, tiledb_ctx_t* ctx, tiledb_group_t* group, - tiledb_query_type_t query_type) noexcept { + tiledb_query_type_t query_type) { return api_entry_context( ctx, group, query_type); } -capi_return_t tiledb_group_close( - tiledb_ctx_t* ctx, tiledb_group_t* group) noexcept { +CAPI_INTERFACE(group_close, tiledb_ctx_t* ctx, tiledb_group_t* group) { return api_entry_context(ctx, group); } -void tiledb_group_free(tiledb_group_t** group) noexcept { +CAPI_INTERFACE_VOID(group_free, tiledb_group_t** group) { return api_entry_void(group); } -capi_return_t tiledb_group_set_config( +CAPI_INTERFACE( + group_set_config, tiledb_ctx_t* ctx, tiledb_group_t* group, - tiledb_config_t* config) noexcept { + tiledb_config_t* config) { return api_entry_context( ctx, group, config); } -capi_return_t tiledb_group_get_config( +CAPI_INTERFACE( + group_get_config, tiledb_ctx_t* ctx, tiledb_group_t* group, - tiledb_config_t** config) noexcept { + tiledb_config_t** config) { return api_entry_context( ctx, group, config); } -capi_return_t tiledb_group_put_metadata( +CAPI_INTERFACE( + group_put_metadata, tiledb_ctx_t* ctx, tiledb_group_t* group, const char* key, tiledb_datatype_t value_type, uint32_t value_num, - const void* value) noexcept { + const void* value) { return api_entry_context( ctx, group, key, value_type, value_num, value); } -capi_return_t tiledb_group_delete_group( +CAPI_INTERFACE( + group_delete_group, tiledb_ctx_t* ctx, tiledb_group_t* group, const char* uri, - const uint8_t recursive) noexcept { + const uint8_t recursive) { return api_entry_context( ctx, group, uri, recursive); } -capi_return_t tiledb_group_delete_metadata( - tiledb_ctx_t* ctx, tiledb_group_t* group, const char* key) noexcept { +CAPI_INTERFACE( + group_delete_metadata, + tiledb_ctx_t* ctx, + tiledb_group_t* group, + const char* key) { return api_entry_context( ctx, group, key); } -capi_return_t tiledb_group_get_metadata( +CAPI_INTERFACE( + group_get_metadata, tiledb_ctx_t* ctx, tiledb_group_t* group, const char* key, tiledb_datatype_t* value_type, uint32_t* value_num, - const void** value) noexcept { + const void** value) { return api_entry_context( ctx, group, key, value_type, value_num, value); } -capi_return_t tiledb_group_get_metadata_num( - tiledb_ctx_t* ctx, tiledb_group_t* group, uint64_t* num) noexcept { +CAPI_INTERFACE( + group_get_metadata_num, + tiledb_ctx_t* ctx, + tiledb_group_t* group, + uint64_t* num) { return api_entry_context( ctx, group, num); } -capi_return_t tiledb_group_get_metadata_from_index( +CAPI_INTERFACE( + group_get_metadata_from_index, tiledb_ctx_t* ctx, tiledb_group_t* group, uint64_t index, @@ -645,153 +659,175 @@ capi_return_t tiledb_group_get_metadata_from_index( uint32_t* key_len, tiledb_datatype_t* value_type, uint32_t* value_num, - const void** value) noexcept { + const void** value) { return api_entry_context( ctx, group, index, key, key_len, value_type, value_num, value); } -capi_return_t tiledb_group_has_metadata_key( +CAPI_INTERFACE( + group_has_metadata_key, tiledb_ctx_t* ctx, tiledb_group_t* group, const char* key, tiledb_datatype_t* value_type, - int32_t* has_key) noexcept { + int32_t* has_key) { return api_entry_context( ctx, group, key, value_type, has_key); } -capi_return_t tiledb_group_add_member( +CAPI_INTERFACE( + group_add_member, tiledb_ctx_t* ctx, tiledb_group_t* group, const char* uri, const uint8_t relative, - const char* name) noexcept { + const char* name) { return api_entry_context( ctx, group, uri, relative, name); } -capi_return_t tiledb_group_remove_member( - tiledb_ctx_t* ctx, tiledb_group_t* group, const char* name) noexcept { +CAPI_INTERFACE( + group_remove_member, + tiledb_ctx_t* ctx, + tiledb_group_t* group, + const char* name) { return api_entry_context( ctx, group, name); } -capi_return_t tiledb_group_get_member_count( - tiledb_ctx_t* ctx, tiledb_group_t* group, uint64_t* count) noexcept { +CAPI_INTERFACE( + group_get_member_count, + tiledb_ctx_t* ctx, + tiledb_group_t* group, + uint64_t* count) { return api_entry_context( ctx, group, count); } -capi_return_t tiledb_group_get_member_by_index( +CAPI_INTERFACE( + group_get_member_by_index, tiledb_ctx_t* ctx, tiledb_group_t* group, uint64_t index, char** uri, tiledb_object_t* type, - char** name) noexcept { + char** name) { return api_entry_context( ctx, group, index, uri, type, name); } -capi_return_t tiledb_group_get_member_by_name( +CAPI_INTERFACE( + group_get_member_by_name, tiledb_ctx_t* ctx, tiledb_group_t* group, const char* name, char** uri, - tiledb_object_t* type) noexcept { + tiledb_object_t* type) { return api_entry_context( ctx, group, name, uri, type); } -capi_return_t tiledb_group_get_is_relative_uri_by_name( +CAPI_INTERFACE( + group_get_is_relative_uri_by_name, tiledb_ctx_t* ctx, tiledb_group_t* group, const char* name, - uint8_t* relative) noexcept { + uint8_t* relative) { return api_entry_context< tiledb::api::tiledb_group_get_is_relative_uri_by_name>( ctx, group, name, relative); } -capi_return_t tiledb_group_is_open( - tiledb_ctx_t* ctx, tiledb_group_t* group, int32_t* is_open) noexcept { +CAPI_INTERFACE( + group_is_open, tiledb_ctx_t* ctx, tiledb_group_t* group, int32_t* is_open) { return api_entry_context( ctx, group, is_open); } -capi_return_t tiledb_group_get_uri( - tiledb_ctx_t* ctx, tiledb_group_t* group, const char** group_uri) noexcept { +CAPI_INTERFACE( + group_get_uri, + tiledb_ctx_t* ctx, + tiledb_group_t* group, + const char** group_uri) { return api_entry_context( ctx, group, group_uri); } -capi_return_t tiledb_group_get_query_type( +CAPI_INTERFACE( + group_get_query_type, tiledb_ctx_t* ctx, tiledb_group_t* group, - tiledb_query_type_t* query_type) noexcept { + tiledb_query_type_t* query_type) { return api_entry_context( ctx, group, query_type); } -capi_return_t tiledb_group_dump_str( +CAPI_INTERFACE( + group_dump_str, tiledb_ctx_t* ctx, tiledb_group_t* group, char** dump_ascii, - const uint8_t recursive) noexcept { + const uint8_t recursive) { return api_entry_context( ctx, group, dump_ascii, recursive); } -capi_return_t tiledb_serialize_group( +CAPI_INTERFACE( + serialize_group, tiledb_ctx_t* ctx, const tiledb_group_t* group, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_buffer_t** buffer_list) noexcept { + tiledb_buffer_t** buffer_list) { return api_entry_context( ctx, group, serialize_type, client_side, buffer_list); } -capi_return_t tiledb_deserialize_group( +CAPI_INTERFACE( + deserialize_group, tiledb_ctx_t* ctx, const tiledb_buffer_t* buffer, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_group_t* group) noexcept { + tiledb_group_t* group) { return api_entry_context( ctx, buffer, serialize_type, client_side, group); } -capi_return_t tiledb_serialize_group_metadata( +CAPI_INTERFACE( + serialize_group_metadata, tiledb_ctx_t* ctx, const tiledb_group_t* group, tiledb_serialization_type_t serialization_type, - tiledb_buffer_t** buffer) noexcept { + tiledb_buffer_t** buffer) { return api_entry_context( ctx, group, serialization_type, buffer); } -capi_return_t tiledb_deserialize_group_metadata( +CAPI_INTERFACE( + deserialize_group_metadata, tiledb_ctx_t* ctx, tiledb_group_t* group, tiledb_serialization_type_t serialization_type, - const tiledb_buffer_t* buffer) noexcept { + const tiledb_buffer_t* buffer) { return api_entry_context( ctx, group, serialization_type, buffer); } -capi_return_t tiledb_group_consolidate_metadata( +CAPI_INTERFACE( + group_consolidate_metadata, tiledb_ctx_t* ctx, const char* group_uri, - tiledb_config_t* config) noexcept { + tiledb_config_t* config) { return api_entry_with_context( ctx, group_uri, config); } -capi_return_t tiledb_group_vacuum_metadata( +CAPI_INTERFACE( + group_vacuum_metadata, tiledb_ctx_t* ctx, const char* group_uri, - tiledb_config_t* config) noexcept { + tiledb_config_t* config) { return api_entry_with_context( ctx, group_uri, config); } diff --git a/tiledb/api/c_api/object/object_api.cc b/tiledb/api/c_api/object/object_api.cc index 1fb3d9de9b1..1fdae8ab6f2 100644 --- a/tiledb/api/c_api/object/object_api.cc +++ b/tiledb/api/c_api/object/object_api.cc @@ -88,26 +88,26 @@ capi_return_t tiledb_walk_order_from_str( using tiledb::api::api_entry_plain; using tiledb::api::api_entry_with_context; -capi_return_t tiledb_object_type_to_str( - tiledb_object_t object_type, const char** str) noexcept { +CAPI_INTERFACE( + object_type_to_str, tiledb_object_t object_type, const char** str) { return api_entry_plain( object_type, str); } -capi_return_t tiledb_object_type_from_str( - const char* str, tiledb_object_t* object_type) noexcept { +CAPI_INTERFACE( + object_type_from_str, const char* str, tiledb_object_t* object_type) { return api_entry_plain( str, object_type); } -capi_return_t tiledb_walk_order_to_str( - tiledb_walk_order_t walk_order, const char** str) noexcept { +CAPI_INTERFACE( + walk_order_to_str, tiledb_walk_order_t walk_order, const char** str) { return api_entry_plain( walk_order, str); } -capi_return_t tiledb_walk_order_from_str( - const char* str, tiledb_walk_order_t* walk_order) noexcept { +CAPI_INTERFACE( + walk_order_from_str, const char* str, tiledb_walk_order_t* walk_order) { return api_entry_plain( str, walk_order); } diff --git a/tiledb/api/c_api/query/query_api.cc b/tiledb/api/c_api/query/query_api.cc index 58f30c06275..496bec15014 100644 --- a/tiledb/api/c_api/query/query_api.cc +++ b/tiledb/api/c_api/query/query_api.cc @@ -57,14 +57,14 @@ int32_t tiledb_query_type_from_str( using tiledb::api::api_entry_plain; -int32_t tiledb_query_type_to_str( - tiledb_query_type_t query_type, const char** str) noexcept { +CAPI_INTERFACE( + query_type_to_str, tiledb_query_type_t query_type, const char** str) { return api_entry_plain( query_type, str); } -int32_t tiledb_query_type_from_str( - const char* str, tiledb_query_type_t* query_type) noexcept { +CAPI_INTERFACE( + query_type_from_str, const char* str, tiledb_query_type_t* query_type) { return api_entry_plain( str, query_type); } diff --git a/tiledb/api/c_api/query_aggregate/query_aggregate_api.cc b/tiledb/api/c_api/query_aggregate/query_aggregate_api.cc index c51f76e31d7..e61dede8383 100644 --- a/tiledb/api/c_api/query_aggregate/query_aggregate_api.cc +++ b/tiledb/api/c_api/query_aggregate/query_aggregate_api.cc @@ -269,77 +269,92 @@ tiledb_channel_operator_handle_t::make_operation( using tiledb::api::api_entry_with_context; -capi_return_t tiledb_channel_operator_sum_get( - tiledb_ctx_t* ctx, const tiledb_channel_operator_t** op) noexcept { +CAPI_INTERFACE( + channel_operator_sum_get, + tiledb_ctx_t* ctx, + const tiledb_channel_operator_t** op) { return api_entry_with_context( ctx, op); } -capi_return_t tiledb_channel_operator_mean_get( - tiledb_ctx_t* ctx, const tiledb_channel_operator_t** op) noexcept { +CAPI_INTERFACE( + channel_operator_mean_get, + tiledb_ctx_t* ctx, + const tiledb_channel_operator_t** op) { return api_entry_with_context( ctx, op); } -capi_return_t tiledb_channel_operator_min_get( - tiledb_ctx_t* ctx, const tiledb_channel_operator_t** op) noexcept { +CAPI_INTERFACE( + channel_operator_min_get, + tiledb_ctx_t* ctx, + const tiledb_channel_operator_t** op) { return api_entry_with_context( ctx, op); } -capi_return_t tiledb_channel_operator_max_get( - tiledb_ctx_t* ctx, const tiledb_channel_operator_t** op) noexcept { +CAPI_INTERFACE( + channel_operator_max_get, + tiledb_ctx_t* ctx, + const tiledb_channel_operator_t** op) { return api_entry_with_context( ctx, op); } -capi_return_t tiledb_channel_operator_null_count_get( - tiledb_ctx_t* ctx, const tiledb_channel_operator_t** op) noexcept { +CAPI_INTERFACE( + channel_operator_null_count_get, + tiledb_ctx_t* ctx, + const tiledb_channel_operator_t** op) { return api_entry_with_context< tiledb::api::tiledb_channel_operator_null_count_get>(ctx, op); } -capi_return_t tiledb_aggregate_count_get( - tiledb_ctx_t* ctx, const tiledb_channel_operation_t** operation) noexcept { +CAPI_INTERFACE( + aggregate_count_get, + tiledb_ctx_t* ctx, + const tiledb_channel_operation_t** operation) { return api_entry_with_context( ctx, operation); } -capi_return_t tiledb_query_get_default_channel( +CAPI_INTERFACE( + query_get_default_channel, tiledb_ctx_t* ctx, tiledb_query_t* query, - tiledb_query_channel_t** channel) noexcept { + tiledb_query_channel_t** channel) { return api_entry_with_context( ctx, query, channel); } -capi_return_t tiledb_create_unary_aggregate( +CAPI_INTERFACE( + create_unary_aggregate, tiledb_ctx_t* ctx, tiledb_query_t* query, const tiledb_channel_operator_t* op, const char* input_field_name, - tiledb_channel_operation_t** operation) noexcept { + tiledb_channel_operation_t** operation) { return api_entry_with_context( ctx, query, op, input_field_name, operation); } -capi_return_t tiledb_channel_apply_aggregate( +CAPI_INTERFACE( + channel_apply_aggregate, tiledb_ctx_t* ctx, tiledb_query_channel_t* channel, const char* output_field_name, - const tiledb_channel_operation_t* operation) noexcept { + const tiledb_channel_operation_t* operation) { return api_entry_with_context( ctx, channel, output_field_name, operation); } -capi_return_t tiledb_aggregate_free( - tiledb_ctx_t* ctx, tiledb_channel_operation_t** operation) noexcept { +CAPI_INTERFACE( + aggregate_free, tiledb_ctx_t* ctx, tiledb_channel_operation_t** operation) { return tiledb::api::api_entry_with_context< tiledb::api::tiledb_aggregate_free>(ctx, operation); } -capi_return_t tiledb_query_channel_free( - tiledb_ctx_t* ctx, tiledb_query_channel_t** channel) noexcept { +CAPI_INTERFACE( + query_channel_free, tiledb_ctx_t* ctx, tiledb_query_channel_t** channel) { return tiledb::api::api_entry_with_context< tiledb::api::tiledb_query_channel_free>(ctx, channel); } diff --git a/tiledb/api/c_api/query_field/query_field_api.cc b/tiledb/api/c_api/query_field/query_field_api.cc index 78355dfee2c..c6b88154c04 100644 --- a/tiledb/api/c_api/query_field/query_field_api.cc +++ b/tiledb/api/c_api/query_field/query_field_api.cc @@ -161,48 +161,53 @@ capi_return_t tiledb_field_channel( using tiledb::api::api_entry_context; -capi_return_t tiledb_query_get_field( +CAPI_INTERFACE( + query_get_field, tiledb_ctx_t* ctx, tiledb_query_t* query, const char* field_name, - tiledb_query_field_t** field) noexcept { + tiledb_query_field_t** field) { return api_entry_context( ctx, query, field_name, field); } -capi_return_t tiledb_query_field_free( - tiledb_ctx_t* ctx, tiledb_query_field_t** field) noexcept { +CAPI_INTERFACE( + query_field_free, tiledb_ctx_t* ctx, tiledb_query_field_t** field) { return api_entry_context(ctx, field); } -capi_return_t tiledb_field_datatype( +CAPI_INTERFACE( + field_datatype, tiledb_ctx_t* ctx, tiledb_query_field_t* field, - tiledb_datatype_t* type) noexcept { + tiledb_datatype_t* type) { return api_entry_context( ctx, field, type); } -capi_return_t tiledb_field_cell_val_num( +CAPI_INTERFACE( + field_cell_val_num, tiledb_ctx_t* ctx, tiledb_query_field_t* field, - uint32_t* cell_val_num) noexcept { + uint32_t* cell_val_num) { return api_entry_context( ctx, field, cell_val_num); } -capi_return_t tiledb_field_origin( +CAPI_INTERFACE( + field_origin, tiledb_ctx_t* ctx, tiledb_query_field_t* field, - tiledb_field_origin_t* origin) noexcept { + tiledb_field_origin_t* origin) { return api_entry_context( ctx, field, origin); } -capi_return_t tiledb_field_channel( +CAPI_INTERFACE( + field_channel, tiledb_ctx_t* ctx, tiledb_query_field_t* field, - tiledb_query_channel_handle_t** channel) noexcept { + tiledb_query_channel_handle_t** channel) { return api_entry_context( ctx, field, channel); } diff --git a/tiledb/api/c_api/query_plan/query_plan_api.cc b/tiledb/api/c_api/query_plan/query_plan_api.cc index 9d622c583f0..e9d7bbfd326 100644 --- a/tiledb/api/c_api/query_plan/query_plan_api.cc +++ b/tiledb/api/c_api/query_plan/query_plan_api.cc @@ -59,10 +59,11 @@ capi_return_t tiledb_query_get_plan( using tiledb::api::api_entry_with_context; -capi_return_t tiledb_query_get_plan( +CAPI_INTERFACE( + query_get_plan, tiledb_ctx_t* ctx, tiledb_query_t* query, - tiledb_string_handle_t** rv) noexcept { + tiledb_string_handle_t** rv) { return api_entry_with_context( ctx, query, rv); } diff --git a/tiledb/api/c_api/string/string_api.cc b/tiledb/api/c_api/string/string_api.cc index 21ba1c00e5a..06012455981 100644 --- a/tiledb/api/c_api/string/string_api.cc +++ b/tiledb/api/c_api/string/string_api.cc @@ -56,12 +56,12 @@ capi_return_t tiledb_string_free(tiledb_string_handle_t** s) { } // namespace tiledb::api -capi_return_t tiledb_string_view( - tiledb_string_t* s, const char** data, size_t* length) noexcept { +CAPI_INTERFACE( + string_view, tiledb_string_t* s, const char** data, size_t* length) { return tiledb::api::api_entry_plain( s, data, length); } -capi_return_t tiledb_string_free(tiledb_string_handle_t** s) noexcept { +CAPI_INTERFACE(string_free, tiledb_string_handle_t** s) { return tiledb::api::api_entry_plain(s); } diff --git a/tiledb/api/c_api/vfs/vfs_api.cc b/tiledb/api/c_api/vfs/vfs_api.cc index 521782e69e9..04144755f0b 100644 --- a/tiledb/api/c_api/vfs/vfs_api.cc +++ b/tiledb/api/c_api/vfs/vfs_api.cc @@ -316,213 +316,231 @@ capi_return_t tiledb_vfs_touch(tiledb_vfs_t* vfs, const char* uri) { using tiledb::api::api_entry_context; using tiledb::api::api_entry_plain; -capi_return_t tiledb_vfs_mode_to_str( - tiledb_vfs_mode_t vfs_mode, const char** str) noexcept { +CAPI_INTERFACE(vfs_mode_to_str, tiledb_vfs_mode_t vfs_mode, const char** str) { return api_entry_plain(vfs_mode, str); } -capi_return_t tiledb_vfs_mode_from_str( - const char* str, tiledb_vfs_mode_t* vfs_mode) noexcept { +CAPI_INTERFACE( + vfs_mode_from_str, const char* str, tiledb_vfs_mode_t* vfs_mode) { return api_entry_plain(str, vfs_mode); } -capi_return_t tiledb_vfs_alloc( - tiledb_ctx_t* ctx, tiledb_config_t* config, tiledb_vfs_t** vfs) noexcept { +CAPI_INTERFACE( + vfs_alloc, tiledb_ctx_t* ctx, tiledb_config_t* config, tiledb_vfs_t** vfs) { return tiledb::api::api_entry_with_context( ctx, config, vfs); } -void tiledb_vfs_free(tiledb_vfs_t** vfs) noexcept { +CAPI_INTERFACE_VOID(vfs_free, tiledb_vfs_t** vfs) { return tiledb::api::api_entry_void(vfs); } -capi_return_t tiledb_vfs_get_config( - tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, tiledb_config_t** config) noexcept { +CAPI_INTERFACE( + vfs_get_config, + tiledb_ctx_t* ctx, + tiledb_vfs_t* vfs, + tiledb_config_t** config) { return api_entry_context( ctx, vfs, config); } -capi_return_t tiledb_vfs_create_bucket( - tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri) noexcept { +CAPI_INTERFACE( + vfs_create_bucket, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri) { return api_entry_context( ctx, vfs, uri); } -capi_return_t tiledb_vfs_remove_bucket( - tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri) noexcept { +CAPI_INTERFACE( + vfs_remove_bucket, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri) { return api_entry_context( ctx, vfs, uri); } -capi_return_t tiledb_vfs_empty_bucket( - tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri) noexcept { +CAPI_INTERFACE( + vfs_empty_bucket, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri) { return api_entry_context(ctx, vfs, uri); } -capi_return_t tiledb_vfs_is_empty_bucket( +CAPI_INTERFACE( + vfs_is_empty_bucket, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri, - int32_t* is_empty) noexcept { + int32_t* is_empty) { return api_entry_context( ctx, vfs, uri, is_empty); } -capi_return_t tiledb_vfs_is_bucket( +CAPI_INTERFACE( + vfs_is_bucket, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri, - int32_t* is_bucket) noexcept { + int32_t* is_bucket) { return api_entry_context( ctx, vfs, uri, is_bucket); } -capi_return_t tiledb_vfs_create_dir( - tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri) noexcept { +CAPI_INTERFACE( + vfs_create_dir, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri) { return api_entry_context(ctx, vfs, uri); } -capi_return_t tiledb_vfs_is_dir( +CAPI_INTERFACE( + vfs_is_dir, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri, - int32_t* is_dir) noexcept { + int32_t* is_dir) { return api_entry_context( ctx, vfs, uri, is_dir); } -capi_return_t tiledb_vfs_remove_dir( - tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri) noexcept { +CAPI_INTERFACE( + vfs_remove_dir, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri) { return api_entry_context(ctx, vfs, uri); } -capi_return_t tiledb_vfs_is_file( +CAPI_INTERFACE( + vfs_is_file, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri, - int32_t* is_file) noexcept { + int32_t* is_file) { return api_entry_context( ctx, vfs, uri, is_file); } -capi_return_t tiledb_vfs_remove_file( - tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri) noexcept { +CAPI_INTERFACE( + vfs_remove_file, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri) { return api_entry_context(ctx, vfs, uri); } -capi_return_t tiledb_vfs_dir_size( +CAPI_INTERFACE( + vfs_dir_size, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri, - uint64_t* size) noexcept { + uint64_t* size) { return api_entry_context( ctx, vfs, uri, size); } -capi_return_t tiledb_vfs_file_size( +CAPI_INTERFACE( + vfs_file_size, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri, - uint64_t* size) noexcept { + uint64_t* size) { return api_entry_context( ctx, vfs, uri, size); } -capi_return_t tiledb_vfs_move_file( +CAPI_INTERFACE( + vfs_move_file, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* old_uri, - const char* new_uri) noexcept { + const char* new_uri) { return api_entry_context( ctx, vfs, old_uri, new_uri); } -capi_return_t tiledb_vfs_move_dir( +CAPI_INTERFACE( + vfs_move_dir, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* old_uri, - const char* new_uri) noexcept { + const char* new_uri) { return api_entry_context( ctx, vfs, old_uri, new_uri); } -capi_return_t tiledb_vfs_copy_file( +CAPI_INTERFACE( + vfs_copy_file, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* old_uri, - const char* new_uri) noexcept { + const char* new_uri) { return api_entry_context( ctx, vfs, old_uri, new_uri); } -capi_return_t tiledb_vfs_copy_dir( +CAPI_INTERFACE( + vfs_copy_dir, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* old_uri, - const char* new_uri) noexcept { + const char* new_uri) { return api_entry_context( ctx, vfs, old_uri, new_uri); } -capi_return_t tiledb_vfs_open( +CAPI_INTERFACE( + vfs_open, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri, tiledb_vfs_mode_t mode, - tiledb_vfs_fh_t** fh) noexcept { + tiledb_vfs_fh_t** fh) { return api_entry_context( ctx, vfs, uri, mode, fh); } -capi_return_t tiledb_vfs_close( - tiledb_ctx_t* ctx, tiledb_vfs_fh_t* fh) noexcept { +CAPI_INTERFACE(vfs_close, tiledb_ctx_t* ctx, tiledb_vfs_fh_t* fh) { return api_entry_context(ctx, fh); } -capi_return_t tiledb_vfs_read( +CAPI_INTERFACE( + vfs_read, tiledb_ctx_t* ctx, tiledb_vfs_fh_t* fh, uint64_t offset, void* buffer, - uint64_t nbytes) noexcept { + uint64_t nbytes) { return api_entry_context( ctx, fh, offset, buffer, nbytes); } -capi_return_t tiledb_vfs_write( +CAPI_INTERFACE( + vfs_write, tiledb_ctx_t* ctx, tiledb_vfs_fh_t* fh, const void* buffer, - uint64_t nbytes) noexcept { + uint64_t nbytes) { return api_entry_context( ctx, fh, buffer, nbytes); } -capi_return_t tiledb_vfs_sync(tiledb_ctx_t* ctx, tiledb_vfs_fh_t* fh) noexcept { +CAPI_INTERFACE(vfs_sync, tiledb_ctx_t* ctx, tiledb_vfs_fh_t* fh) { return api_entry_context(ctx, fh); } -capi_return_t tiledb_vfs_ls( +CAPI_INTERFACE( + vfs_ls, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* path, int32_t (*callback)(const char*, void*), - void* data) noexcept { + void* data) { return api_entry_context( ctx, vfs, path, callback, data); } -void tiledb_vfs_fh_free(tiledb_vfs_fh_t** fh) noexcept { +CAPI_INTERFACE_VOID(vfs_fh_free, tiledb_vfs_fh_t** fh) { return tiledb::api::api_entry_void(fh); } -capi_return_t tiledb_vfs_fh_is_closed( - tiledb_ctx_t* ctx, tiledb_vfs_fh_t* fh, int32_t* is_closed) noexcept { +CAPI_INTERFACE( + vfs_fh_is_closed, + tiledb_ctx_t* ctx, + tiledb_vfs_fh_t* fh, + int32_t* is_closed) { return api_entry_context( ctx, fh, is_closed); } -capi_return_t tiledb_vfs_touch( - tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri) noexcept { +CAPI_INTERFACE( + vfs_touch, tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const char* uri) { return api_entry_context(ctx, vfs, uri); } diff --git a/tiledb/api/c_api_support/exception_wrapper/capi_definition.h b/tiledb/api/c_api_support/exception_wrapper/capi_definition.h index cd45eb219cf..619844622cd 100644 --- a/tiledb/api/c_api_support/exception_wrapper/capi_definition.h +++ b/tiledb/api/c_api_support/exception_wrapper/capi_definition.h @@ -56,6 +56,13 @@ capi_return_t tiledb_##root(__VA_ARGS__) noexcept CAPI_PREFIX(root) \ void tiledb_##root(__VA_ARGS__) noexcept +/* + * A variant of CAPI_INTERFACE for the handful of functions without arguments. + */ +#define CAPI_INTERFACE_NULL(root) \ +CAPI_PREFIX(root) \ +capi_return_t tiledb_##root(void) noexcept + /* clang-format on */ #endif // TILEDB_CAPI_DEFINITION_H diff --git a/tiledb/sm/c_api/tiledb.cc b/tiledb/sm/c_api/tiledb.cc index 10d55edc3c3..9501b4d1cfd 100644 --- a/tiledb/sm/c_api/tiledb.cc +++ b/tiledb/sm/c_api/tiledb.cc @@ -5251,60 +5251,68 @@ constexpr auto api_entry = tiledb::api::api_entry_with_context; /* ****************************** */ /* ENUMS TO/FROM STR */ /* ****************************** */ -int32_t tiledb_array_type_to_str( - tiledb_array_type_t array_type, const char** str) noexcept { +CAPI_INTERFACE( + array_type_to_str, tiledb_array_type_t array_type, const char** str) { return api_entry_plain( array_type, str); } -int32_t tiledb_array_type_from_str( - const char* str, tiledb_array_type_t* array_type) noexcept { +CAPI_INTERFACE( + array_type_from_str, const char* str, tiledb_array_type_t* array_type) { return api_entry_plain( str, array_type); } -int32_t tiledb_layout_to_str( - tiledb_layout_t layout, const char** str) noexcept { +CAPI_INTERFACE(layout_to_str, tiledb_layout_t layout, const char** str) { return api_entry_plain(layout, str); } -int32_t tiledb_layout_from_str( - const char* str, tiledb_layout_t* layout) noexcept { +CAPI_INTERFACE(layout_from_str, const char* str, tiledb_layout_t* layout) { return api_entry_plain(str, layout); } -int32_t tiledb_encryption_type_to_str( - tiledb_encryption_type_t encryption_type, const char** str) noexcept { +CAPI_INTERFACE( + encryption_type_to_str, + tiledb_encryption_type_t encryption_type, + const char** str) { return api_entry_plain( encryption_type, str); } -int32_t tiledb_encryption_type_from_str( - const char* str, tiledb_encryption_type_t* encryption_type) noexcept { +CAPI_INTERFACE( + encryption_type_from_str, + const char* str, + tiledb_encryption_type_t* encryption_type) { return api_entry_plain( str, encryption_type); } -int32_t tiledb_query_status_to_str( - tiledb_query_status_t query_status, const char** str) noexcept { +CAPI_INTERFACE( + query_status_to_str, tiledb_query_status_t query_status, const char** str) { return api_entry_plain( query_status, str); } -int32_t tiledb_query_status_from_str( - const char* str, tiledb_query_status_t* query_status) noexcept { +CAPI_INTERFACE( + query_status_from_str, + const char* str, + tiledb_query_status_t* query_status) { return api_entry_plain( str, query_status); } -int32_t tiledb_serialization_type_to_str( - tiledb_serialization_type_t serialization_type, const char** str) noexcept { +CAPI_INTERFACE( + serialization_type_to_str, + tiledb_serialization_type_t serialization_type, + const char** str) { return api_entry_plain( serialization_type, str); } -int32_t tiledb_serialization_type_from_str( - const char* str, tiledb_serialization_type_t* serialization_type) noexcept { +CAPI_INTERFACE( + serialization_type_from_str, + const char* str, + tiledb_serialization_type_t* serialization_type) { return api_entry_plain( str, serialization_type); } @@ -5357,14 +5365,14 @@ void tiledb_version(int32_t* major, int32_t* minor, int32_t* rev) noexcept { /* LOGGING */ /* ********************************* */ -capi_return_t tiledb_log_warn(tiledb_ctx_t* ctx, const char* message) { +CAPI_INTERFACE(log_warn, tiledb_ctx_t* ctx, const char* message) { return api_entry(ctx, message); } /* ********************************* */ /* AS BUILT */ /* ********************************* */ -capi_return_t tiledb_as_built_dump(tiledb_string_t** out) noexcept { +CAPI_INTERFACE(as_built_dump, tiledb_string_t** out) { return api_entry_plain(out); } @@ -5372,143 +5380,161 @@ capi_return_t tiledb_as_built_dump(tiledb_string_t** out) noexcept { /* ARRAY SCHEMA */ /* ****************************** */ -int32_t tiledb_array_schema_alloc( +CAPI_INTERFACE( + array_schema_alloc, tiledb_ctx_t* ctx, tiledb_array_type_t array_type, - tiledb_array_schema_t** array_schema) noexcept { + tiledb_array_schema_t** array_schema) { return api_entry( ctx, array_type, array_schema); } -void tiledb_array_schema_free(tiledb_array_schema_t** array_schema) noexcept { +CAPI_INTERFACE_VOID(array_schema_free, tiledb_array_schema_t** array_schema) { return api_entry_void(array_schema); } -int32_t tiledb_array_schema_add_attribute( +CAPI_INTERFACE( + array_schema_add_attribute, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, - tiledb_attribute_t* attr) noexcept { + tiledb_attribute_t* attr) { return api_entry( ctx, array_schema, attr); } -int32_t tiledb_array_schema_set_allows_dups( +CAPI_INTERFACE( + array_schema_set_allows_dups, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, - int allows_dups) noexcept { + int allows_dups) { return api_entry( ctx, array_schema, allows_dups); } -int32_t tiledb_array_schema_get_allows_dups( +CAPI_INTERFACE( + array_schema_get_allows_dups, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, - int* allows_dups) noexcept { + int* allows_dups) { return api_entry( ctx, array_schema, allows_dups); } -int32_t tiledb_array_schema_get_version( +CAPI_INTERFACE( + array_schema_get_version, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, - uint32_t* version) noexcept { + uint32_t* version) { return api_entry( ctx, array_schema, version); } -int32_t tiledb_array_schema_set_domain( +CAPI_INTERFACE( + array_schema_set_domain, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, - tiledb_domain_t* domain) noexcept { + tiledb_domain_t* domain) { return api_entry( ctx, array_schema, domain); } -int32_t tiledb_array_schema_set_capacity( +CAPI_INTERFACE( + array_schema_set_capacity, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, - uint64_t capacity) noexcept { + uint64_t capacity) { return api_entry( ctx, array_schema, capacity); } -int32_t tiledb_array_schema_set_cell_order( +CAPI_INTERFACE( + array_schema_set_cell_order, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, - tiledb_layout_t cell_order) noexcept { + tiledb_layout_t cell_order) { return api_entry( ctx, array_schema, cell_order); } -int32_t tiledb_array_schema_set_tile_order( +CAPI_INTERFACE( + array_schema_set_tile_order, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, - tiledb_layout_t tile_order) noexcept { + tiledb_layout_t tile_order) { return api_entry( ctx, array_schema, tile_order); } -int32_t tiledb_array_schema_timestamp_range( +CAPI_INTERFACE( + array_schema_timestamp_range, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, uint64_t* lo, - uint64_t* hi) noexcept { + uint64_t* hi) { return api_entry( ctx, array_schema, lo, hi); } -int32_t tiledb_array_schema_add_enumeration( +CAPI_INTERFACE( + array_schema_add_enumeration, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, - tiledb_enumeration_t* enumeration) noexcept { + tiledb_enumeration_t* enumeration) { return api_entry( ctx, array_schema, enumeration); } -int32_t tiledb_array_schema_set_coords_filter_list( +CAPI_INTERFACE( + array_schema_set_coords_filter_list, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, - tiledb_filter_list_t* filter_list) noexcept { + tiledb_filter_list_t* filter_list) { return api_entry( ctx, array_schema, filter_list); } -int32_t tiledb_array_schema_set_offsets_filter_list( +CAPI_INTERFACE( + array_schema_set_offsets_filter_list, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, - tiledb_filter_list_t* filter_list) noexcept { + tiledb_filter_list_t* filter_list) { return api_entry( ctx, array_schema, filter_list); } -int32_t tiledb_array_schema_set_validity_filter_list( +CAPI_INTERFACE( + array_schema_set_validity_filter_list, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, - tiledb_filter_list_t* filter_list) noexcept { + tiledb_filter_list_t* filter_list) { return api_entry( ctx, array_schema, filter_list); } -int32_t tiledb_array_schema_check( - tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema) noexcept { +CAPI_INTERFACE( + array_schema_check, + tiledb_ctx_t* ctx, + tiledb_array_schema_t* array_schema) { return api_entry(ctx, array_schema); } -int32_t tiledb_array_schema_load( +CAPI_INTERFACE( + array_schema_load, tiledb_ctx_t* ctx, const char* array_uri, - tiledb_array_schema_t** array_schema) noexcept { + tiledb_array_schema_t** array_schema) { return api_entry( ctx, array_uri, array_schema); } -int32_t tiledb_array_schema_load_with_key( +CAPI_INTERFACE( + array_schema_load_with_key, tiledb_ctx_t* ctx, const char* array_uri, tiledb_encryption_type_t encryption_type, const void* encryption_key, uint32_t key_length, - tiledb_array_schema_t** array_schema) noexcept { + tiledb_array_schema_t** array_schema) { return api_entry( ctx, array_uri, @@ -5518,109 +5544,122 @@ int32_t tiledb_array_schema_load_with_key( array_schema); } -int32_t tiledb_array_schema_get_array_type( +CAPI_INTERFACE( + array_schema_get_array_type, tiledb_ctx_t* ctx, const tiledb_array_schema_t* array_schema, - tiledb_array_type_t* array_type) noexcept { + tiledb_array_type_t* array_type) { return api_entry( ctx, array_schema, array_type); } -int32_t tiledb_array_schema_get_capacity( +CAPI_INTERFACE( + array_schema_get_capacity, tiledb_ctx_t* ctx, const tiledb_array_schema_t* array_schema, - uint64_t* capacity) noexcept { + uint64_t* capacity) { return api_entry( ctx, array_schema, capacity); } -int32_t tiledb_array_schema_get_cell_order( +CAPI_INTERFACE( + array_schema_get_cell_order, tiledb_ctx_t* ctx, const tiledb_array_schema_t* array_schema, - tiledb_layout_t* cell_order) noexcept { + tiledb_layout_t* cell_order) { return api_entry( ctx, array_schema, cell_order); } -int32_t tiledb_array_schema_get_coords_filter_list( +CAPI_INTERFACE( + array_schema_get_coords_filter_list, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, - tiledb_filter_list_t** filter_list) noexcept { + tiledb_filter_list_t** filter_list) { return api_entry( ctx, array_schema, filter_list); } -int32_t tiledb_array_schema_get_offsets_filter_list( +CAPI_INTERFACE( + array_schema_get_offsets_filter_list, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, - tiledb_filter_list_t** filter_list) noexcept { + tiledb_filter_list_t** filter_list) { return api_entry( ctx, array_schema, filter_list); } -int32_t tiledb_array_schema_get_validity_filter_list( +CAPI_INTERFACE( + array_schema_get_validity_filter_list, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, - tiledb_filter_list_t** filter_list) noexcept { + tiledb_filter_list_t** filter_list) { return api_entry( ctx, array_schema, filter_list); } -int32_t tiledb_array_schema_get_domain( +CAPI_INTERFACE( + array_schema_get_domain, tiledb_ctx_t* ctx, const tiledb_array_schema_t* array_schema, - tiledb_domain_t** domain) noexcept { + tiledb_domain_t** domain) { return api_entry( ctx, array_schema, domain); } -int32_t tiledb_array_schema_get_tile_order( +CAPI_INTERFACE( + array_schema_get_tile_order, tiledb_ctx_t* ctx, const tiledb_array_schema_t* array_schema, - tiledb_layout_t* tile_order) noexcept { + tiledb_layout_t* tile_order) { return api_entry( ctx, array_schema, tile_order); } -int32_t tiledb_array_schema_get_attribute_num( +CAPI_INTERFACE( + array_schema_get_attribute_num, tiledb_ctx_t* ctx, const tiledb_array_schema_t* array_schema, - uint32_t* attribute_num) noexcept { + uint32_t* attribute_num) { return api_entry( ctx, array_schema, attribute_num); } -int32_t tiledb_array_schema_dump( +CAPI_INTERFACE( + array_schema_dump, tiledb_ctx_t* ctx, const tiledb_array_schema_t* array_schema, - FILE* out) noexcept { + FILE* out) { return api_entry( ctx, array_schema, out); } -int32_t tiledb_array_schema_get_attribute_from_index( +CAPI_INTERFACE( + array_schema_get_attribute_from_index, tiledb_ctx_t* ctx, const tiledb_array_schema_t* array_schema, uint32_t index, - tiledb_attribute_t** attr) noexcept { + tiledb_attribute_t** attr) { return api_entry( ctx, array_schema, index, attr); } -int32_t tiledb_array_schema_get_attribute_from_name( +CAPI_INTERFACE( + array_schema_get_attribute_from_name, tiledb_ctx_t* ctx, const tiledb_array_schema_t* array_schema, const char* name, - tiledb_attribute_t** attr) noexcept { + tiledb_attribute_t** attr) { return api_entry( ctx, array_schema, name, attr); } -int32_t tiledb_array_schema_has_attribute( +CAPI_INTERFACE( + array_schema_has_attribute, tiledb_ctx_t* ctx, const tiledb_array_schema_t* array_schema, const char* name, - int32_t* has_attr) noexcept { + int32_t* has_attr) { return api_entry( ctx, array_schema, name, has_attr); } @@ -5629,56 +5668,63 @@ int32_t tiledb_array_schema_has_attribute( /* SCHEMA EVOLUTION */ /* ********************************* */ -int32_t tiledb_array_schema_evolution_alloc( +CAPI_INTERFACE( + array_schema_evolution_alloc, tiledb_ctx_t* ctx, - tiledb_array_schema_evolution_t** array_schema_evolution) noexcept { + tiledb_array_schema_evolution_t** array_schema_evolution) { return api_entry( ctx, array_schema_evolution); } -void tiledb_array_schema_evolution_free( - tiledb_array_schema_evolution_t** array_schema_evolution) noexcept { +CAPI_INTERFACE_VOID( + array_schema_evolution_free, + tiledb_array_schema_evolution_t** array_schema_evolution) { return api_entry_void( array_schema_evolution); } -int32_t tiledb_array_schema_evolution_add_attribute( +CAPI_INTERFACE( + array_schema_evolution_add_attribute, tiledb_ctx_t* ctx, tiledb_array_schema_evolution_t* array_schema_evolution, - tiledb_attribute_t* attr) noexcept { + tiledb_attribute_t* attr) { return api_entry( ctx, array_schema_evolution, attr); } -int32_t tiledb_array_schema_evolution_drop_attribute( +CAPI_INTERFACE( + array_schema_evolution_drop_attribute, tiledb_ctx_t* ctx, tiledb_array_schema_evolution_t* array_schema_evolution, - const char* attribute_name) noexcept { + const char* attribute_name) { return api_entry( ctx, array_schema_evolution, attribute_name); } -int32_t tiledb_array_schema_evolution_add_enumeration( +CAPI_INTERFACE( + array_schema_evolution_add_enumeration, tiledb_ctx_t* ctx, tiledb_array_schema_evolution_t* array_schema_evolution, - tiledb_enumeration_t* enmr) noexcept { + tiledb_enumeration_t* enmr) { return api_entry( ctx, array_schema_evolution, enmr); } -capi_return_t tiledb_array_schema_evolution_extend_enumeration( +CAPI_INTERFACE( + array_schema_evolution_extend_enumeration, tiledb_ctx_t* ctx, tiledb_array_schema_evolution_t* array_schema_evolution, - tiledb_enumeration_t* enmr) noexcept { + tiledb_enumeration_t* enmr) { return api_entry< tiledb::api::tiledb_array_schema_evolution_extend_enumeration>( ctx, array_schema_evolution, enmr); } -capi_return_t tiledb_array_schema_evolution_drop_enumeration( +CAPI_INTERFACE( + array_schema_evolution_drop_enumeration, tiledb_ctx_t* ctx, tiledb_array_schema_evolution_t* array_schema_evolution, - const char* enumeration_name) noexcept { + const char* enumeration_name) { return api_entry( ctx, array_schema_evolution, enumeration_name); } @@ -5697,400 +5743,451 @@ TILEDB_EXPORT int32_t tiledb_array_schema_evolution_set_timestamp_range( /* QUERY */ /* ****************************** */ -int32_t tiledb_query_alloc( +CAPI_INTERFACE( + query_alloc, tiledb_ctx_t* ctx, tiledb_array_t* array, tiledb_query_type_t query_type, - tiledb_query_t** query) noexcept { + tiledb_query_t** query) { return api_entry( ctx, array, query_type, query); } -int32_t tiledb_query_get_stats( - tiledb_ctx_t* ctx, tiledb_query_t* query, char** stats_json) noexcept { +CAPI_INTERFACE( + query_get_stats, + tiledb_ctx_t* ctx, + tiledb_query_t* query, + char** stats_json) { return api_entry(ctx, query, stats_json); } -int32_t tiledb_query_set_config( +CAPI_INTERFACE( + query_set_config, tiledb_ctx_t* ctx, tiledb_query_t* query, - tiledb_config_t* config) noexcept { + tiledb_config_t* config) { return api_entry(ctx, query, config); } -int32_t tiledb_query_get_config( +CAPI_INTERFACE( + query_get_config, tiledb_ctx_t* ctx, tiledb_query_t* query, - tiledb_config_t** config) noexcept { + tiledb_config_t** config) { return api_entry(ctx, query, config); } -int32_t tiledb_query_set_subarray( +CAPI_INTERFACE( + query_set_subarray, tiledb_ctx_t* ctx, tiledb_query_t* query, - const void* subarray_vals) noexcept { + const void* subarray_vals) { return api_entry( ctx, query, subarray_vals); } -int32_t tiledb_query_set_subarray_t( +CAPI_INTERFACE( + query_set_subarray_t, tiledb_ctx_t* ctx, tiledb_query_t* query, - const tiledb_subarray_t* subarray) noexcept { + const tiledb_subarray_t* subarray) { return api_entry( ctx, query, subarray); } -int32_t tiledb_query_set_data_buffer( +CAPI_INTERFACE( + query_set_data_buffer, tiledb_ctx_t* ctx, tiledb_query_t* query, const char* name, void* buffer, - uint64_t* buffer_size) noexcept { + uint64_t* buffer_size) { return api_entry( ctx, query, name, buffer, buffer_size); } -int32_t tiledb_query_set_offsets_buffer( +CAPI_INTERFACE( + query_set_offsets_buffer, tiledb_ctx_t* ctx, tiledb_query_t* query, const char* name, uint64_t* buffer_offsets, - uint64_t* buffer_offsets_size) noexcept { + uint64_t* buffer_offsets_size) { return api_entry( ctx, query, name, buffer_offsets, buffer_offsets_size); } -int32_t tiledb_query_set_validity_buffer( +CAPI_INTERFACE( + query_set_validity_buffer, tiledb_ctx_t* ctx, tiledb_query_t* query, const char* name, uint8_t* buffer_validity, - uint64_t* buffer_validity_size) noexcept { + uint64_t* buffer_validity_size) { return api_entry( ctx, query, name, buffer_validity, buffer_validity_size); } -int32_t tiledb_query_get_data_buffer( +CAPI_INTERFACE( + query_get_data_buffer, tiledb_ctx_t* ctx, tiledb_query_t* query, const char* name, void** buffer, - uint64_t** buffer_size) noexcept { + uint64_t** buffer_size) { return api_entry( ctx, query, name, buffer, buffer_size); } -int32_t tiledb_query_get_offsets_buffer( +CAPI_INTERFACE( + query_get_offsets_buffer, tiledb_ctx_t* ctx, tiledb_query_t* query, const char* name, uint64_t** buffer, - uint64_t** buffer_size) noexcept { + uint64_t** buffer_size) { return api_entry( ctx, query, name, buffer, buffer_size); } -int32_t tiledb_query_get_validity_buffer( +CAPI_INTERFACE( + query_get_validity_buffer, tiledb_ctx_t* ctx, tiledb_query_t* query, const char* name, uint8_t** buffer, - uint64_t** buffer_size) noexcept { + uint64_t** buffer_size) { return api_entry( ctx, query, name, buffer, buffer_size); } -int32_t tiledb_query_set_layout( - tiledb_ctx_t* ctx, tiledb_query_t* query, tiledb_layout_t layout) noexcept { +CAPI_INTERFACE( + query_set_layout, + tiledb_ctx_t* ctx, + tiledb_query_t* query, + tiledb_layout_t layout) { return api_entry(ctx, query, layout); } -int32_t tiledb_query_set_condition( +CAPI_INTERFACE( + query_set_condition, tiledb_ctx_t* const ctx, tiledb_query_t* const query, - const tiledb_query_condition_t* const cond) noexcept { + const tiledb_query_condition_t* const cond) { return api_entry(ctx, query, cond); } -int32_t tiledb_query_finalize( - tiledb_ctx_t* ctx, tiledb_query_t* query) noexcept { +CAPI_INTERFACE(query_finalize, tiledb_ctx_t* ctx, tiledb_query_t* query) { return api_entry(ctx, query); } -int32_t tiledb_query_submit_and_finalize( - tiledb_ctx_t* ctx, tiledb_query_t* query) noexcept { +CAPI_INTERFACE( + query_submit_and_finalize, tiledb_ctx_t* ctx, tiledb_query_t* query) { return api_entry(ctx, query); } -void tiledb_query_free(tiledb_query_t** query) noexcept { +CAPI_INTERFACE_VOID(query_free, tiledb_query_t** query) { return api_entry_void(query); } -int32_t tiledb_query_submit(tiledb_ctx_t* ctx, tiledb_query_t* query) noexcept { +CAPI_INTERFACE(query_submit, tiledb_ctx_t* ctx, tiledb_query_t* query) { return api_entry(ctx, query); } -int32_t tiledb_query_submit_async( +CAPI_INTERFACE( + query_submit_async, tiledb_ctx_t* ctx, tiledb_query_t* query, void (*callback)(void*), - void* callback_data) noexcept { + void* callback_data) { return api_entry( ctx, query, callback, callback_data); } -int32_t tiledb_query_has_results( - tiledb_ctx_t* ctx, tiledb_query_t* query, int32_t* has_results) noexcept { +CAPI_INTERFACE( + query_has_results, + tiledb_ctx_t* ctx, + tiledb_query_t* query, + int32_t* has_results) { return api_entry( ctx, query, has_results); } -int32_t tiledb_query_get_status( +CAPI_INTERFACE( + query_get_status, tiledb_ctx_t* ctx, tiledb_query_t* query, - tiledb_query_status_t* status) noexcept { + tiledb_query_status_t* status) { return api_entry(ctx, query, status); } -int32_t tiledb_query_get_type( +CAPI_INTERFACE( + query_get_type, tiledb_ctx_t* ctx, tiledb_query_t* query, - tiledb_query_type_t* query_type) noexcept { + tiledb_query_type_t* query_type) { return api_entry(ctx, query, query_type); } -int32_t tiledb_query_get_layout( +CAPI_INTERFACE( + query_get_layout, tiledb_ctx_t* ctx, tiledb_query_t* query, - tiledb_layout_t* query_layout) noexcept { + tiledb_layout_t* query_layout) { return api_entry( ctx, query, query_layout); } -int32_t tiledb_query_get_array( - tiledb_ctx_t* ctx, tiledb_query_t* query, tiledb_array_t** array) noexcept { +CAPI_INTERFACE( + query_get_array, + tiledb_ctx_t* ctx, + tiledb_query_t* query, + tiledb_array_t** array) { return api_entry(ctx, query, array); } -int32_t tiledb_query_add_range( +CAPI_INTERFACE( + query_add_range, tiledb_ctx_t* ctx, tiledb_query_t* query, uint32_t dim_idx, const void* start, const void* end, - const void* stride) noexcept { + const void* stride) { return api_entry( ctx, query, dim_idx, start, end, stride); } -int32_t tiledb_query_add_point_ranges( +CAPI_INTERFACE( + query_add_point_ranges, tiledb_ctx_t* ctx, tiledb_query_t* query, uint32_t dim_idx, const void* start, - uint64_t count) noexcept { + uint64_t count) { return api_entry( ctx, query, dim_idx, start, count); } -int32_t tiledb_query_add_range_by_name( +CAPI_INTERFACE( + query_add_range_by_name, tiledb_ctx_t* ctx, tiledb_query_t* query, const char* dim_name, const void* start, const void* end, - const void* stride) noexcept { + const void* stride) { return api_entry( ctx, query, dim_name, start, end, stride); } -int32_t tiledb_query_add_range_var( +CAPI_INTERFACE( + query_add_range_var, tiledb_ctx_t* ctx, tiledb_query_t* query, uint32_t dim_idx, const void* start, uint64_t start_size, const void* end, - uint64_t end_size) noexcept { + uint64_t end_size) { return api_entry( ctx, query, dim_idx, start, start_size, end, end_size); } -int32_t tiledb_query_add_range_var_by_name( +CAPI_INTERFACE( + query_add_range_var_by_name, tiledb_ctx_t* ctx, tiledb_query_t* query, const char* dim_name, const void* start, uint64_t start_size, const void* end, - uint64_t end_size) noexcept { + uint64_t end_size) { return api_entry( ctx, query, dim_name, start, start_size, end, end_size); } -int32_t tiledb_query_get_range_num( +CAPI_INTERFACE( + query_get_range_num, tiledb_ctx_t* ctx, const tiledb_query_t* query, uint32_t dim_idx, - uint64_t* range_num) noexcept { + uint64_t* range_num) { return api_entry( ctx, query, dim_idx, range_num); } -int32_t tiledb_query_get_range_num_from_name( +CAPI_INTERFACE( + query_get_range_num_from_name, tiledb_ctx_t* ctx, const tiledb_query_t* query, const char* dim_name, - uint64_t* range_num) noexcept { + uint64_t* range_num) { return api_entry( ctx, query, dim_name, range_num); } -int32_t tiledb_query_get_range( +CAPI_INTERFACE( + query_get_range, tiledb_ctx_t* ctx, const tiledb_query_t* query, uint32_t dim_idx, uint64_t range_idx, const void** start, const void** end, - const void** stride) noexcept { + const void** stride) { return api_entry( ctx, query, dim_idx, range_idx, start, end, stride); } -int32_t tiledb_query_get_range_from_name( +CAPI_INTERFACE( + query_get_range_from_name, tiledb_ctx_t* ctx, const tiledb_query_t* query, const char* dim_name, uint64_t range_idx, const void** start, const void** end, - const void** stride) noexcept { + const void** stride) { return api_entry( ctx, query, dim_name, range_idx, start, end, stride); } -int32_t tiledb_query_get_range_var_size( +CAPI_INTERFACE( + query_get_range_var_size, tiledb_ctx_t* ctx, const tiledb_query_t* query, uint32_t dim_idx, uint64_t range_idx, uint64_t* start_size, - uint64_t* end_size) noexcept { + uint64_t* end_size) { return api_entry( ctx, query, dim_idx, range_idx, start_size, end_size); } -int32_t tiledb_query_get_range_var_size_from_name( +CAPI_INTERFACE( + query_get_range_var_size_from_name, tiledb_ctx_t* ctx, const tiledb_query_t* query, const char* dim_name, uint64_t range_idx, uint64_t* start_size, - uint64_t* end_size) noexcept { + uint64_t* end_size) { return api_entry( ctx, query, dim_name, range_idx, start_size, end_size); } -int32_t tiledb_query_get_range_var( +CAPI_INTERFACE( + query_get_range_var, tiledb_ctx_t* ctx, const tiledb_query_t* query, uint32_t dim_idx, uint64_t range_idx, void* start, - void* end) noexcept { + void* end) { return api_entry( ctx, query, dim_idx, range_idx, start, end); } -int32_t tiledb_query_get_range_var_from_name( +CAPI_INTERFACE( + query_get_range_var_from_name, tiledb_ctx_t* ctx, const tiledb_query_t* query, const char* dim_name, uint64_t range_idx, void* start, - void* end) noexcept { + void* end) { return api_entry( ctx, query, dim_name, range_idx, start, end); } -int32_t tiledb_query_get_est_result_size( +CAPI_INTERFACE( + query_get_est_result_size, tiledb_ctx_t* ctx, const tiledb_query_t* query, const char* name, - uint64_t* size) noexcept { + uint64_t* size) { return api_entry( ctx, query, name, size); } -int32_t tiledb_query_get_est_result_size_var( +CAPI_INTERFACE( + query_get_est_result_size_var, tiledb_ctx_t* ctx, const tiledb_query_t* query, const char* name, uint64_t* size_off, - uint64_t* size_val) noexcept { + uint64_t* size_val) { return api_entry( ctx, query, name, size_off, size_val); } -int32_t tiledb_query_get_est_result_size_nullable( +CAPI_INTERFACE( + query_get_est_result_size_nullable, tiledb_ctx_t* ctx, const tiledb_query_t* query, const char* name, uint64_t* size_val, - uint64_t* size_validity) noexcept { + uint64_t* size_validity) { return api_entry( ctx, query, name, size_val, size_validity); } -int32_t tiledb_query_get_est_result_size_var_nullable( +CAPI_INTERFACE( + query_get_est_result_size_var_nullable, tiledb_ctx_t* ctx, const tiledb_query_t* query, const char* name, uint64_t* size_off, uint64_t* size_val, - uint64_t* size_validity) noexcept { + uint64_t* size_validity) { return api_entry( ctx, query, name, size_off, size_val, size_validity); } -int32_t tiledb_query_get_fragment_num( - tiledb_ctx_t* ctx, const tiledb_query_t* query, uint32_t* num) noexcept { +CAPI_INTERFACE( + query_get_fragment_num, + tiledb_ctx_t* ctx, + const tiledb_query_t* query, + uint32_t* num) { return api_entry(ctx, query, num); } -int32_t tiledb_query_get_fragment_uri( +CAPI_INTERFACE( + query_get_fragment_uri, tiledb_ctx_t* ctx, const tiledb_query_t* query, uint64_t idx, - const char** uri) noexcept { + const char** uri) { return api_entry( ctx, query, idx, uri); } -int32_t tiledb_query_get_fragment_timestamp_range( +CAPI_INTERFACE( + query_get_fragment_timestamp_range, tiledb_ctx_t* ctx, const tiledb_query_t* query, uint64_t idx, uint64_t* t1, - uint64_t* t2) noexcept { + uint64_t* t2) { return api_entry( ctx, query, idx, t1, t2); } -int32_t tiledb_query_get_subarray_t( +CAPI_INTERFACE( + query_get_subarray_t, tiledb_ctx_t* ctx, const tiledb_query_t* query, - tiledb_subarray_t** subarray) noexcept { + tiledb_subarray_t** subarray) { return api_entry( ctx, query, subarray); } -int32_t tiledb_query_get_relevant_fragment_num( +CAPI_INTERFACE( + query_get_relevant_fragment_num, tiledb_ctx_t* ctx, const tiledb_query_t* query, - uint64_t* relevant_fragment_num) noexcept { + uint64_t* relevant_fragment_num) { return api_entry( ctx, query, relevant_fragment_num); } @@ -6099,179 +6196,196 @@ int32_t tiledb_query_get_relevant_fragment_num( /* SUBARRAY */ /* ****************************** */ -int32_t tiledb_subarray_alloc( +CAPI_INTERFACE( + subarray_alloc, tiledb_ctx_t* ctx, const tiledb_array_t* array, - tiledb_subarray_t** subarray) noexcept { + tiledb_subarray_t** subarray) { return api_entry(ctx, array, subarray); } -int32_t tiledb_subarray_set_config( +CAPI_INTERFACE( + subarray_set_config, tiledb_ctx_t* ctx, tiledb_subarray_t* subarray, - tiledb_config_t* config) noexcept { + tiledb_config_t* config) { return api_entry( ctx, subarray, config); } -void tiledb_subarray_free(tiledb_subarray_t** subarray) noexcept { +CAPI_INTERFACE_VOID(subarray_free, tiledb_subarray_t** subarray) { return api_entry_void(subarray); } -int32_t tiledb_subarray_set_coalesce_ranges( +CAPI_INTERFACE( + subarray_set_coalesce_ranges, tiledb_ctx_t* ctx, tiledb_subarray_t* subarray, - int coalesce_ranges) noexcept { + int coalesce_ranges) { return api_entry( ctx, subarray, coalesce_ranges); } -int32_t tiledb_subarray_set_subarray( +CAPI_INTERFACE( + subarray_set_subarray, tiledb_ctx_t* ctx, tiledb_subarray_t* subarray_obj, - const void* subarray_vals) noexcept { + const void* subarray_vals) { return api_entry( ctx, subarray_obj, subarray_vals); } -int32_t tiledb_subarray_add_range( +CAPI_INTERFACE( + subarray_add_range, tiledb_ctx_t* ctx, tiledb_subarray_t* subarray, uint32_t dim_idx, const void* start, const void* end, - const void* stride) noexcept { + const void* stride) { return api_entry( ctx, subarray, dim_idx, start, end, stride); } -int32_t tiledb_subarray_add_point_ranges( +CAPI_INTERFACE( + subarray_add_point_ranges, tiledb_ctx_t* ctx, tiledb_subarray_t* subarray, uint32_t dim_idx, const void* start, - uint64_t count) noexcept { + uint64_t count) { return api_entry( ctx, subarray, dim_idx, start, count); } -int32_t tiledb_subarray_add_range_by_name( +CAPI_INTERFACE( + subarray_add_range_by_name, tiledb_ctx_t* ctx, tiledb_subarray_t* subarray, const char* dim_name, const void* start, const void* end, - const void* stride) noexcept { + const void* stride) { return api_entry( ctx, subarray, dim_name, start, end, stride); } -int32_t tiledb_subarray_add_range_var( +CAPI_INTERFACE( + subarray_add_range_var, tiledb_ctx_t* ctx, tiledb_subarray_t* subarray, uint32_t dim_idx, const void* start, uint64_t start_size, const void* end, - uint64_t end_size) noexcept { + uint64_t end_size) { return api_entry( ctx, subarray, dim_idx, start, start_size, end, end_size); } -int32_t tiledb_subarray_add_range_var_by_name( +CAPI_INTERFACE( + subarray_add_range_var_by_name, tiledb_ctx_t* ctx, tiledb_subarray_t* subarray, const char* dim_name, const void* start, uint64_t start_size, const void* end, - uint64_t end_size) noexcept { + uint64_t end_size) { return api_entry( ctx, subarray, dim_name, start, start_size, end, end_size); } -int32_t tiledb_subarray_get_range_num( +CAPI_INTERFACE( + subarray_get_range_num, tiledb_ctx_t* ctx, const tiledb_subarray_t* subarray, uint32_t dim_idx, - uint64_t* range_num) noexcept { + uint64_t* range_num) { return api_entry( ctx, subarray, dim_idx, range_num); } -int32_t tiledb_subarray_get_range_num_from_name( +CAPI_INTERFACE( + subarray_get_range_num_from_name, tiledb_ctx_t* ctx, const tiledb_subarray_t* subarray, const char* dim_name, - uint64_t* range_num) noexcept { + uint64_t* range_num) { return api_entry( ctx, subarray, dim_name, range_num); } -int32_t tiledb_subarray_get_range( +CAPI_INTERFACE( + subarray_get_range, tiledb_ctx_t* ctx, const tiledb_subarray_t* subarray, uint32_t dim_idx, uint64_t range_idx, const void** start, const void** end, - const void** stride) noexcept { + const void** stride) { return api_entry( ctx, subarray, dim_idx, range_idx, start, end, stride); } -int32_t tiledb_subarray_get_range_var_size( +CAPI_INTERFACE( + subarray_get_range_var_size, tiledb_ctx_t* ctx, const tiledb_subarray_t* subarray, uint32_t dim_idx, uint64_t range_idx, uint64_t* start_size, - uint64_t* end_size) noexcept { + uint64_t* end_size) { return api_entry( ctx, subarray, dim_idx, range_idx, start_size, end_size); } -int32_t tiledb_subarray_get_range_from_name( +CAPI_INTERFACE( + subarray_get_range_from_name, tiledb_ctx_t* ctx, const tiledb_subarray_t* subarray, const char* dim_name, uint64_t range_idx, const void** start, const void** end, - const void** stride) noexcept { + const void** stride) { return api_entry( ctx, subarray, dim_name, range_idx, start, end, stride); } -int32_t tiledb_subarray_get_range_var_size_from_name( +CAPI_INTERFACE( + subarray_get_range_var_size_from_name, tiledb_ctx_t* ctx, const tiledb_subarray_t* subarray, const char* dim_name, uint64_t range_idx, uint64_t* start_size, - uint64_t* end_size) noexcept { + uint64_t* end_size) { return api_entry( ctx, subarray, dim_name, range_idx, start_size, end_size); } -int32_t tiledb_subarray_get_range_var( +CAPI_INTERFACE( + subarray_get_range_var, tiledb_ctx_t* ctx, const tiledb_subarray_t* subarray, uint32_t dim_idx, uint64_t range_idx, void* start, - void* end) noexcept { + void* end) { return api_entry( ctx, subarray, dim_idx, range_idx, start, end); } -int32_t tiledb_subarray_get_range_var_from_name( +CAPI_INTERFACE( + subarray_get_range_var_from_name, tiledb_ctx_t* ctx, const tiledb_subarray_t* subarray, const char* dim_name, uint64_t range_idx, void* start, - void* end) noexcept { + void* end) { return api_entry( ctx, subarray, dim_name, range_idx, start, end); } @@ -6280,12 +6394,15 @@ int32_t tiledb_subarray_get_range_var_from_name( /* QUERY CONDITION */ /* ****************************** */ -int32_t tiledb_query_condition_alloc( - tiledb_ctx_t* const ctx, tiledb_query_condition_t** const cond) noexcept { +CAPI_INTERFACE( + query_condition_alloc, + tiledb_ctx_t* const ctx, + tiledb_query_condition_t** const cond) { return api_entry(ctx, cond); } -capi_return_t tiledb_query_condition_alloc_set_membership( +CAPI_INTERFACE( + query_condition_alloc_set_membership, tiledb_ctx_t* ctx, const char* field_name, const void* data, @@ -6293,49 +6410,53 @@ capi_return_t tiledb_query_condition_alloc_set_membership( const void* offsets, uint64_t offsets_size, tiledb_query_condition_op_t op, - tiledb_query_condition_t** cond) noexcept { + tiledb_query_condition_t** cond) { return api_entry_context< tiledb::api::tiledb_query_condition_alloc_set_membership>( ctx, field_name, data, data_size, offsets, offsets_size, op, cond); } -void tiledb_query_condition_free(tiledb_query_condition_t** cond) noexcept { +CAPI_INTERFACE_VOID(query_condition_free, tiledb_query_condition_t** cond) { return api_entry_void(cond); } -int32_t tiledb_query_condition_init( +CAPI_INTERFACE( + query_condition_init, tiledb_ctx_t* const ctx, tiledb_query_condition_t* const cond, const char* const attribute_name, const void* const condition_value, const uint64_t condition_value_size, - const tiledb_query_condition_op_t op) noexcept { + const tiledb_query_condition_op_t op) { return api_entry( ctx, cond, attribute_name, condition_value, condition_value_size, op); } -int32_t tiledb_query_condition_combine( +CAPI_INTERFACE( + query_condition_combine, tiledb_ctx_t* const ctx, const tiledb_query_condition_t* const left_cond, const tiledb_query_condition_t* const right_cond, const tiledb_query_condition_combination_op_t combination_op, - tiledb_query_condition_t** const combined_cond) noexcept { + tiledb_query_condition_t** const combined_cond) { return api_entry( ctx, left_cond, right_cond, combination_op, combined_cond); } -int32_t tiledb_query_condition_negate( +CAPI_INTERFACE( + query_condition_negate, tiledb_ctx_t* const ctx, const tiledb_query_condition_t* const cond, - tiledb_query_condition_t** const negated_cond) noexcept { + tiledb_query_condition_t** const negated_cond) { return api_entry( ctx, cond, negated_cond); } -capi_return_t tiledb_query_condition_set_use_enumeration( +CAPI_INTERFACE( + query_condition_set_use_enumeration, tiledb_ctx_t* const ctx, const tiledb_query_condition_t* const cond, - int use_enumeration) noexcept { + int use_enumeration) { return api_entry( ctx, cond, use_enumeration); } @@ -6344,12 +6465,13 @@ capi_return_t tiledb_query_condition_set_use_enumeration( /* UPDATE CONDITION */ /* ****************************** */ -int32_t tiledb_query_add_update_value( +CAPI_INTERFACE( + query_add_update_value, tiledb_ctx_t* ctx, tiledb_query_t* query, const char* field_name, const void* update_value, - uint64_t update_value_size) noexcept { + uint64_t update_value_size) { return api_entry( ctx, query, field_name, update_value, update_value_size); } @@ -6358,147 +6480,169 @@ int32_t tiledb_query_add_update_value( /* ARRAY */ /* ****************************** */ -int32_t tiledb_array_alloc( - tiledb_ctx_t* ctx, const char* array_uri, tiledb_array_t** array) noexcept { +CAPI_INTERFACE( + array_alloc, + tiledb_ctx_t* ctx, + const char* array_uri, + tiledb_array_t** array) { return api_entry(ctx, array_uri, array); } -int32_t tiledb_array_set_open_timestamp_start( +CAPI_INTERFACE( + array_set_open_timestamp_start, tiledb_ctx_t* ctx, tiledb_array_t* array, - uint64_t timestamp_start) noexcept { + uint64_t timestamp_start) { return api_entry( ctx, array, timestamp_start); } -int32_t tiledb_array_set_open_timestamp_end( - tiledb_ctx_t* ctx, tiledb_array_t* array, uint64_t timestamp_end) noexcept { +CAPI_INTERFACE( + array_set_open_timestamp_end, + tiledb_ctx_t* ctx, + tiledb_array_t* array, + uint64_t timestamp_end) { return api_entry( ctx, array, timestamp_end); } -int32_t tiledb_array_get_open_timestamp_start( +CAPI_INTERFACE( + array_get_open_timestamp_start, tiledb_ctx_t* ctx, tiledb_array_t* array, - uint64_t* timestamp_start) noexcept { + uint64_t* timestamp_start) { return api_entry( ctx, array, timestamp_start); } -int32_t tiledb_array_get_open_timestamp_end( +CAPI_INTERFACE( + array_get_open_timestamp_end, tiledb_ctx_t* ctx, tiledb_array_t* array, - uint64_t* timestamp_end) noexcept { + uint64_t* timestamp_end) { return api_entry( ctx, array, timestamp_end); } -int32_t tiledb_array_delete(tiledb_ctx_t* ctx, const char* uri) noexcept { +CAPI_INTERFACE(array_delete, tiledb_ctx_t* ctx, const char* uri) { return api_entry(ctx, uri); } -int32_t tiledb_array_delete_array( - tiledb_ctx_t* ctx, tiledb_array_t* array, const char* uri) noexcept { +CAPI_INTERFACE( + array_delete_array, + tiledb_ctx_t* ctx, + tiledb_array_t* array, + const char* uri) { return api_entry(ctx, array, uri); } -int32_t tiledb_array_delete_fragments( +CAPI_INTERFACE( + array_delete_fragments, tiledb_ctx_t* ctx, tiledb_array_t* array, const char* uri, uint64_t timestamp_start, - uint64_t timestamp_end) noexcept { + uint64_t timestamp_end) { return api_entry( ctx, array, uri, timestamp_start, timestamp_end); } -capi_return_t tiledb_array_delete_fragments_v2( +CAPI_INTERFACE( + array_delete_fragments_v2, tiledb_ctx_t* ctx, const char* uri_str, uint64_t timestamp_start, - uint64_t timestamp_end) noexcept { + uint64_t timestamp_end) { return api_entry( ctx, uri_str, timestamp_start, timestamp_end); } -capi_return_t tiledb_array_delete_fragments_list( +CAPI_INTERFACE( + array_delete_fragments_list, tiledb_ctx_t* ctx, const char* uri_str, const char* fragment_uris[], - const size_t num_fragments) noexcept { + const size_t num_fragments) { return api_entry( ctx, uri_str, fragment_uris, num_fragments); } -int32_t tiledb_array_open( +CAPI_INTERFACE( + array_open, tiledb_ctx_t* ctx, tiledb_array_t* array, - tiledb_query_type_t query_type) noexcept { + tiledb_query_type_t query_type) { return api_entry(ctx, array, query_type); } -int32_t tiledb_array_is_open( - tiledb_ctx_t* ctx, tiledb_array_t* array, int32_t* is_open) noexcept { +CAPI_INTERFACE( + array_is_open, tiledb_ctx_t* ctx, tiledb_array_t* array, int32_t* is_open) { return api_entry(ctx, array, is_open); } -int32_t tiledb_array_reopen(tiledb_ctx_t* ctx, tiledb_array_t* array) noexcept { +CAPI_INTERFACE(array_reopen, tiledb_ctx_t* ctx, tiledb_array_t* array) { return api_entry(ctx, array); } -int32_t tiledb_array_set_config( +CAPI_INTERFACE( + array_set_config, tiledb_ctx_t* ctx, tiledb_array_t* array, - tiledb_config_t* config) noexcept { + tiledb_config_t* config) { return api_entry(ctx, array, config); } -int32_t tiledb_array_get_config( +CAPI_INTERFACE( + array_get_config, tiledb_ctx_t* ctx, tiledb_array_t* array, - tiledb_config_t** config) noexcept { + tiledb_config_t** config) { return api_entry(ctx, array, config); } -int32_t tiledb_array_close(tiledb_ctx_t* ctx, tiledb_array_t* array) noexcept { +CAPI_INTERFACE(array_close, tiledb_ctx_t* ctx, tiledb_array_t* array) { return api_entry(ctx, array); } -void tiledb_array_free(tiledb_array_t** array) noexcept { +CAPI_INTERFACE_VOID(array_free, tiledb_array_t** array) { return api_entry_void(array); } -int32_t tiledb_array_get_schema( +CAPI_INTERFACE( + array_get_schema, tiledb_ctx_t* ctx, tiledb_array_t* array, - tiledb_array_schema_t** array_schema) noexcept { + tiledb_array_schema_t** array_schema) { return api_entry( ctx, array, array_schema); } -int32_t tiledb_array_get_query_type( +CAPI_INTERFACE( + array_get_query_type, tiledb_ctx_t* ctx, tiledb_array_t* array, - tiledb_query_type_t* query_type) noexcept { + tiledb_query_type_t* query_type) { return api_entry( ctx, array, query_type); } -int32_t tiledb_array_create( +CAPI_INTERFACE( + array_create, tiledb_ctx_t* ctx, const char* array_uri, - const tiledb_array_schema_t* array_schema) noexcept { + const tiledb_array_schema_t* array_schema) { return api_entry( ctx, array_uri, array_schema); } -int32_t tiledb_array_create_with_key( +CAPI_INTERFACE( + array_create_with_key, tiledb_ctx_t* ctx, const char* array_uri, const tiledb_array_schema_t* array_schema, tiledb_encryption_type_t encryption_type, const void* encryption_key, - uint32_t key_length) noexcept { + uint32_t key_length) { return api_entry( ctx, array_uri, @@ -6508,165 +6652,189 @@ int32_t tiledb_array_create_with_key( key_length); } -int32_t tiledb_array_consolidate( +CAPI_INTERFACE( + array_consolidate, tiledb_ctx_t* ctx, const char* array_uri, - tiledb_config_t* config) noexcept { + tiledb_config_t* config) { return api_entry( ctx, array_uri, config); } -int32_t tiledb_array_consolidate_with_key( +CAPI_INTERFACE( + array_consolidate_with_key, tiledb_ctx_t* ctx, const char* array_uri, tiledb_encryption_type_t encryption_type, const void* encryption_key, uint32_t key_length, - tiledb_config_t* config) noexcept { + tiledb_config_t* config) { return api_entry( ctx, array_uri, encryption_type, encryption_key, key_length, config); } -int32_t tiledb_array_consolidate_fragments( +CAPI_INTERFACE( + array_consolidate_fragments, tiledb_ctx_t* ctx, const char* array_uri, const char** fragment_uris, const uint64_t num_fragments, - tiledb_config_t* config) noexcept { + tiledb_config_t* config) { return api_entry( ctx, array_uri, fragment_uris, num_fragments, config); } -int32_t tiledb_array_vacuum( +CAPI_INTERFACE( + array_vacuum, tiledb_ctx_t* ctx, const char* array_uri, - tiledb_config_t* config) noexcept { + tiledb_config_t* config) { return api_entry(ctx, array_uri, config); } -int32_t tiledb_array_get_non_empty_domain( +CAPI_INTERFACE( + array_get_non_empty_domain, tiledb_ctx_t* ctx, tiledb_array_t* array, void* domain, - int32_t* is_empty) noexcept { + int32_t* is_empty) { return api_entry( ctx, array, domain, is_empty); } -int32_t tiledb_array_get_non_empty_domain_from_index( +CAPI_INTERFACE( + array_get_non_empty_domain_from_index, tiledb_ctx_t* ctx, tiledb_array_t* array, uint32_t idx, void* domain, - int32_t* is_empty) noexcept { + int32_t* is_empty) { return api_entry( ctx, array, idx, domain, is_empty); } -int32_t tiledb_array_get_non_empty_domain_from_name( +CAPI_INTERFACE( + array_get_non_empty_domain_from_name, tiledb_ctx_t* ctx, tiledb_array_t* array, const char* name, void* domain, - int32_t* is_empty) noexcept { + int32_t* is_empty) { return api_entry( ctx, array, name, domain, is_empty); } -int32_t tiledb_array_get_non_empty_domain_var_size_from_index( +CAPI_INTERFACE( + array_get_non_empty_domain_var_size_from_index, tiledb_ctx_t* ctx, tiledb_array_t* array, uint32_t idx, uint64_t* start_size, uint64_t* end_size, - int32_t* is_empty) noexcept { + int32_t* is_empty) { return api_entry< tiledb::api::tiledb_array_get_non_empty_domain_var_size_from_index>( ctx, array, idx, start_size, end_size, is_empty); } -int32_t tiledb_array_get_non_empty_domain_var_size_from_name( +CAPI_INTERFACE( + array_get_non_empty_domain_var_size_from_name, tiledb_ctx_t* ctx, tiledb_array_t* array, const char* name, uint64_t* start_size, uint64_t* end_size, - int32_t* is_empty) noexcept { + int32_t* is_empty) { return api_entry< tiledb::api::tiledb_array_get_non_empty_domain_var_size_from_name>( ctx, array, name, start_size, end_size, is_empty); } -int32_t tiledb_array_get_non_empty_domain_var_from_index( +CAPI_INTERFACE( + array_get_non_empty_domain_var_from_index, tiledb_ctx_t* ctx, tiledb_array_t* array, uint32_t idx, void* start, void* end, - int32_t* is_empty) noexcept { + int32_t* is_empty) { return api_entry< tiledb::api::tiledb_array_get_non_empty_domain_var_from_index>( ctx, array, idx, start, end, is_empty); } -int32_t tiledb_array_get_non_empty_domain_var_from_name( +CAPI_INTERFACE( + array_get_non_empty_domain_var_from_name, tiledb_ctx_t* ctx, tiledb_array_t* array, const char* name, void* start, void* end, - int32_t* is_empty) noexcept { + int32_t* is_empty) { return api_entry< tiledb::api::tiledb_array_get_non_empty_domain_var_from_name>( ctx, array, name, start, end, is_empty); } -int32_t tiledb_array_get_uri( - tiledb_ctx_t* ctx, tiledb_array_t* array, const char** array_uri) noexcept { +CAPI_INTERFACE( + array_get_uri, + tiledb_ctx_t* ctx, + tiledb_array_t* array, + const char** array_uri) { return api_entry(ctx, array, array_uri); } -int32_t tiledb_array_encryption_type( +CAPI_INTERFACE( + array_encryption_type, tiledb_ctx_t* ctx, const char* array_uri, - tiledb_encryption_type_t* encryption_type) noexcept { + tiledb_encryption_type_t* encryption_type) { return api_entry( ctx, array_uri, encryption_type); } -int32_t tiledb_array_put_metadata( +CAPI_INTERFACE( + array_put_metadata, tiledb_ctx_t* ctx, tiledb_array_t* array, const char* key, tiledb_datatype_t value_type, uint32_t value_num, - const void* value) noexcept { + const void* value) { return api_entry( ctx, array, key, value_type, value_num, value); } -int32_t tiledb_array_delete_metadata( - tiledb_ctx_t* ctx, tiledb_array_t* array, const char* key) noexcept { +CAPI_INTERFACE( + array_delete_metadata, + tiledb_ctx_t* ctx, + tiledb_array_t* array, + const char* key) { return api_entry(ctx, array, key); } -int32_t tiledb_array_get_metadata( +CAPI_INTERFACE( + array_get_metadata, tiledb_ctx_t* ctx, tiledb_array_t* array, const char* key, tiledb_datatype_t* value_type, uint32_t* value_num, - const void** value) noexcept { + const void** value) { return api_entry( ctx, array, key, value_type, value_num, value); } -int32_t tiledb_array_get_metadata_num( - tiledb_ctx_t* ctx, tiledb_array_t* array, uint64_t* num) noexcept { +CAPI_INTERFACE( + array_get_metadata_num, + tiledb_ctx_t* ctx, + tiledb_array_t* array, + uint64_t* num) { return api_entry(ctx, array, num); } -int32_t tiledb_array_get_metadata_from_index( +CAPI_INTERFACE( + array_get_metadata_from_index, tiledb_ctx_t* ctx, tiledb_array_t* array, uint64_t index, @@ -6674,47 +6842,53 @@ int32_t tiledb_array_get_metadata_from_index( uint32_t* key_len, tiledb_datatype_t* value_type, uint32_t* value_num, - const void** value) noexcept { + const void** value) { return api_entry( ctx, array, index, key, key_len, value_type, value_num, value); } -int32_t tiledb_array_has_metadata_key( +CAPI_INTERFACE( + array_has_metadata_key, tiledb_ctx_t* ctx, tiledb_array_t* array, const char* key, tiledb_datatype_t* value_type, - int32_t* has_key) noexcept { + int32_t* has_key) { return api_entry( ctx, array, key, value_type, has_key); } -int32_t tiledb_array_evolve( +CAPI_INTERFACE( + array_evolve, tiledb_ctx_t* ctx, const char* array_uri, - tiledb_array_schema_evolution_t* array_schema_evolution) noexcept { + tiledb_array_schema_evolution_t* array_schema_evolution) { return api_entry( ctx, array_uri, array_schema_evolution); } -capi_return_t tiledb_array_get_enumeration( +CAPI_INTERFACE( + array_get_enumeration, tiledb_ctx_t* ctx, const tiledb_array_t* array, const char* attr_name, - tiledb_enumeration_t** enumeration) noexcept { + tiledb_enumeration_t** enumeration) { return api_entry( ctx, array, attr_name, enumeration); } -capi_return_t tiledb_array_load_all_enumerations( - tiledb_ctx_t* ctx, const tiledb_array_t* array) noexcept { +CAPI_INTERFACE( + array_load_all_enumerations, + tiledb_ctx_t* ctx, + const tiledb_array_t* array) { return api_entry(ctx, array); } -int32_t tiledb_array_upgrade_version( +CAPI_INTERFACE( + array_upgrade_version, tiledb_ctx_t* ctx, const char* array_uri, - tiledb_config_t* config) noexcept { + tiledb_config_t* config) { return api_entry( ctx, array_uri, config); } @@ -6723,35 +6897,40 @@ int32_t tiledb_array_upgrade_version( /* OBJECT MANAGEMENT */ /* ****************************** */ -int32_t tiledb_object_type( - tiledb_ctx_t* ctx, const char* path, tiledb_object_t* type) noexcept { +CAPI_INTERFACE( + object_type, tiledb_ctx_t* ctx, const char* path, tiledb_object_t* type) { return api_entry(ctx, path, type); } -int32_t tiledb_object_remove(tiledb_ctx_t* ctx, const char* path) noexcept { +CAPI_INTERFACE(object_remove, tiledb_ctx_t* ctx, const char* path) { return api_entry(ctx, path); } -int32_t tiledb_object_move( - tiledb_ctx_t* ctx, const char* old_path, const char* new_path) noexcept { +CAPI_INTERFACE( + object_move, + tiledb_ctx_t* ctx, + const char* old_path, + const char* new_path) { return api_entry(ctx, old_path, new_path); } -int32_t tiledb_object_walk( +CAPI_INTERFACE( + object_walk, tiledb_ctx_t* ctx, const char* path, tiledb_walk_order_t order, int32_t (*callback)(const char*, tiledb_object_t, void*), - void* data) noexcept { + void* data) { return api_entry( ctx, path, order, callback, data); } -int32_t tiledb_object_ls( +CAPI_INTERFACE( + object_ls, tiledb_ctx_t* ctx, const char* path, int32_t (*callback)(const char*, tiledb_object_t, void*), - void* data) noexcept { + void* data) { return api_entry(ctx, path, callback, data); } @@ -6759,11 +6938,12 @@ int32_t tiledb_object_ls( /* URI */ /* ****************************** */ -int32_t tiledb_uri_to_path( +CAPI_INTERFACE( + uri_to_path, tiledb_ctx_t* ctx, const char* uri, char* path_out, - uint32_t* path_length) noexcept { + uint32_t* path_length) { return api_entry( ctx, uri, path_out, path_length); } @@ -6772,35 +6952,35 @@ int32_t tiledb_uri_to_path( /* Stats */ /* ****************************** */ -int32_t tiledb_stats_enable() noexcept { +CAPI_INTERFACE_NULL(stats_enable) { return api_entry_plain(); } -int32_t tiledb_stats_disable() noexcept { +CAPI_INTERFACE_NULL(stats_disable) { return api_entry_plain(); } -int32_t tiledb_stats_reset() noexcept { +CAPI_INTERFACE_NULL(stats_reset) { return api_entry_plain(); } -int32_t tiledb_stats_dump(FILE* out) noexcept { +CAPI_INTERFACE(stats_dump, FILE* out) { return api_entry_plain(out); } -int32_t tiledb_stats_dump_str(char** out) noexcept { +CAPI_INTERFACE(stats_dump_str, char** out) { return api_entry_plain(out); } -int32_t tiledb_stats_raw_dump(FILE* out) noexcept { +CAPI_INTERFACE(stats_raw_dump, FILE* out) { return api_entry_plain(out); } -int32_t tiledb_stats_raw_dump_str(char** out) noexcept { +CAPI_INTERFACE(stats_raw_dump_str, char** out) { return api_entry_plain(out); } -int32_t tiledb_stats_free_str(char** out) noexcept { +CAPI_INTERFACE(stats_free_str, char** out) { return api_entry_plain(out); } @@ -6808,11 +6988,12 @@ int32_t tiledb_stats_free_str(char** out) noexcept { /* Heap Profiler */ /* ****************************** */ -int32_t tiledb_heap_profiler_enable( +CAPI_INTERFACE( + heap_profiler_enable, const char* const file_name_prefix, const uint64_t dump_interval_ms, const uint64_t dump_interval_bytes, - const uint64_t dump_threshold_bytes) noexcept { + const uint64_t dump_threshold_bytes) { return api_entry_plain( file_name_prefix, dump_interval_ms, @@ -6824,126 +7005,138 @@ int32_t tiledb_heap_profiler_enable( /* Serialization */ /* ****************************** */ -int32_t tiledb_serialize_array( +CAPI_INTERFACE( + serialize_array, tiledb_ctx_t* ctx, const tiledb_array_t* array, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_buffer_t** buffer) noexcept { + tiledb_buffer_t** buffer) { return api_entry( ctx, array, serialize_type, client_side, buffer); } -int32_t tiledb_deserialize_array( +CAPI_INTERFACE( + deserialize_array, tiledb_ctx_t* ctx, const tiledb_buffer_t* buffer, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_array_t** array) noexcept { + tiledb_array_t** array) { return api_entry( ctx, buffer, serialize_type, client_side, array); } -int32_t tiledb_serialize_array_schema( +CAPI_INTERFACE( + serialize_array_schema, tiledb_ctx_t* ctx, const tiledb_array_schema_t* array_schema, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_buffer_t** buffer) noexcept { + tiledb_buffer_t** buffer) { return api_entry( ctx, array_schema, serialize_type, client_side, buffer); } -int32_t tiledb_deserialize_array_schema( +CAPI_INTERFACE( + deserialize_array_schema, tiledb_ctx_t* ctx, const tiledb_buffer_t* buffer, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_array_schema_t** array_schema) noexcept { + tiledb_array_schema_t** array_schema) { return api_entry( ctx, buffer, serialize_type, client_side, array_schema); } -int32_t tiledb_serialize_array_open( +CAPI_INTERFACE( + serialize_array_open, tiledb_ctx_t* ctx, const tiledb_array_t* array, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_buffer_t** buffer) noexcept { + tiledb_buffer_t** buffer) { return api_entry( ctx, array, serialize_type, client_side, buffer); } -int32_t tiledb_deserialize_array_open( +CAPI_INTERFACE( + deserialize_array_open, tiledb_ctx_t* ctx, const tiledb_buffer_t* buffer, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_array_t** array) noexcept { + tiledb_array_t** array) { return api_entry( ctx, buffer, serialize_type, client_side, array); } -int32_t tiledb_serialize_array_schema_evolution( +CAPI_INTERFACE( + serialize_array_schema_evolution, tiledb_ctx_t* ctx, const tiledb_array_schema_evolution_t* array_schema_evolution, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_buffer_t** buffer) noexcept { + tiledb_buffer_t** buffer) { return api_entry( ctx, array_schema_evolution, serialize_type, client_side, buffer); } -int32_t tiledb_deserialize_array_schema_evolution( +CAPI_INTERFACE( + deserialize_array_schema_evolution, tiledb_ctx_t* ctx, const tiledb_buffer_t* buffer, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_array_schema_evolution_t** array_schema_evolution) noexcept { + tiledb_array_schema_evolution_t** array_schema_evolution) { return api_entry( ctx, buffer, serialize_type, client_side, array_schema_evolution); } -int32_t tiledb_serialize_query( +CAPI_INTERFACE( + serialize_query, tiledb_ctx_t* ctx, const tiledb_query_t* query, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_buffer_list_t** buffer_list) noexcept { + tiledb_buffer_list_t** buffer_list) { return api_entry( ctx, query, serialize_type, client_side, buffer_list); } -int32_t tiledb_deserialize_query( +CAPI_INTERFACE( + deserialize_query, tiledb_ctx_t* ctx, const tiledb_buffer_t* buffer, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_query_t* query) noexcept { + tiledb_query_t* query) { return api_entry( ctx, buffer, serialize_type, client_side, query); } -int32_t tiledb_deserialize_query_and_array( +CAPI_INTERFACE( + deserialize_query_and_array, tiledb_ctx_t* ctx, const tiledb_buffer_t* buffer, tiledb_serialization_type_t serialize_type, int32_t client_side, const char* array_uri, tiledb_query_t** query, - tiledb_array_t** array) noexcept { + tiledb_array_t** array) { return api_entry( ctx, buffer, serialize_type, client_side, array_uri, query, array); } -int32_t tiledb_serialize_array_nonempty_domain( +CAPI_INTERFACE( + serialize_array_nonempty_domain, tiledb_ctx_t* ctx, const tiledb_array_t* array, const void* nonempty_domain, int32_t is_empty, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_buffer_t** buffer) noexcept { + tiledb_buffer_t** buffer) { return api_entry( ctx, array, @@ -6954,14 +7147,15 @@ int32_t tiledb_serialize_array_nonempty_domain( buffer); } -int32_t tiledb_deserialize_array_nonempty_domain( +CAPI_INTERFACE( + deserialize_array_nonempty_domain, tiledb_ctx_t* ctx, const tiledb_array_t* array, const tiledb_buffer_t* buffer, tiledb_serialization_type_t serialize_type, int32_t client_side, void* nonempty_domain, - int32_t* is_empty) noexcept { + int32_t* is_empty) { return api_entry( ctx, array, @@ -6972,173 +7166,190 @@ int32_t tiledb_deserialize_array_nonempty_domain( is_empty); } -int32_t tiledb_serialize_array_non_empty_domain_all_dimensions( +CAPI_INTERFACE( + serialize_array_non_empty_domain_all_dimensions, tiledb_ctx_t* ctx, const tiledb_array_t* array, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_buffer_t** buffer) noexcept { + tiledb_buffer_t** buffer) { return api_entry< tiledb::api::tiledb_serialize_array_non_empty_domain_all_dimensions>( ctx, array, serialize_type, client_side, buffer); } -int32_t tiledb_deserialize_array_non_empty_domain_all_dimensions( +CAPI_INTERFACE( + deserialize_array_non_empty_domain_all_dimensions, tiledb_ctx_t* ctx, tiledb_array_t* array, const tiledb_buffer_t* buffer, tiledb_serialization_type_t serialize_type, - int32_t client_side) noexcept { + int32_t client_side) { return api_entry< tiledb::api::tiledb_deserialize_array_non_empty_domain_all_dimensions>( ctx, array, buffer, serialize_type, client_side); } -int32_t tiledb_serialize_array_max_buffer_sizes( +CAPI_INTERFACE( + serialize_array_max_buffer_sizes, tiledb_ctx_t* ctx, const tiledb_array_t* array, const void* subarray, tiledb_serialization_type_t serialize_type, - tiledb_buffer_t** buffer) noexcept { + tiledb_buffer_t** buffer) { return api_entry( ctx, array, subarray, serialize_type, buffer); } -capi_return_t tiledb_handle_array_delete_fragments_timestamps_request( +CAPI_INTERFACE( + handle_array_delete_fragments_timestamps_request, tiledb_ctx_t* ctx, tiledb_array_t* array, tiledb_serialization_type_t serialize_type, - const tiledb_buffer_t* request) noexcept { + const tiledb_buffer_t* request) { return api_entry< tiledb::api::tiledb_handle_array_delete_fragments_timestamps_request>( ctx, array, serialize_type, request); } -capi_return_t tiledb_handle_array_delete_fragments_list_request( +CAPI_INTERFACE( + handle_array_delete_fragments_list_request, tiledb_ctx_t* ctx, tiledb_array_t* array, tiledb_serialization_type_t serialize_type, - const tiledb_buffer_t* request) noexcept { + const tiledb_buffer_t* request) { return api_entry< tiledb::api::tiledb_handle_array_delete_fragments_list_request>( ctx, array, serialize_type, request); } -int32_t tiledb_serialize_array_metadata( +CAPI_INTERFACE( + serialize_array_metadata, tiledb_ctx_t* ctx, const tiledb_array_t* array, tiledb_serialization_type_t serialize_type, - tiledb_buffer_t** buffer) noexcept { + tiledb_buffer_t** buffer) { return api_entry( ctx, array, serialize_type, buffer); } -int32_t tiledb_deserialize_array_metadata( +CAPI_INTERFACE( + deserialize_array_metadata, tiledb_ctx_t* ctx, tiledb_array_t* array, tiledb_serialization_type_t serialize_type, - const tiledb_buffer_t* buffer) noexcept { + const tiledb_buffer_t* buffer) { return api_entry( ctx, array, serialize_type, buffer); } -int32_t tiledb_serialize_query_est_result_sizes( +CAPI_INTERFACE( + serialize_query_est_result_sizes, tiledb_ctx_t* ctx, const tiledb_query_t* query, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_buffer_t** buffer) noexcept { + tiledb_buffer_t** buffer) { return api_entry( ctx, query, serialize_type, client_side, buffer); } -int32_t tiledb_deserialize_query_est_result_sizes( +CAPI_INTERFACE( + deserialize_query_est_result_sizes, tiledb_ctx_t* ctx, tiledb_query_t* query, tiledb_serialization_type_t serialize_type, int32_t client_side, - const tiledb_buffer_t* buffer) noexcept { + const tiledb_buffer_t* buffer) { return api_entry( ctx, query, serialize_type, client_side, buffer); } -int32_t tiledb_serialize_config( +CAPI_INTERFACE( + serialize_config, tiledb_ctx_t* ctx, const tiledb_config_t* config, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_buffer_t** buffer) noexcept { + tiledb_buffer_t** buffer) { return api_entry( ctx, config, serialize_type, client_side, buffer); } -int32_t tiledb_deserialize_config( +CAPI_INTERFACE( + deserialize_config, tiledb_ctx_t* ctx, const tiledb_buffer_t* buffer, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_config_t** config) noexcept { + tiledb_config_t** config) { return api_entry_context( ctx, buffer, serialize_type, client_side, config); } -int32_t tiledb_serialize_fragment_info_request( +CAPI_INTERFACE( + serialize_fragment_info_request, tiledb_ctx_t* ctx, const tiledb_fragment_info_t* fragment_info, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_buffer_t** buffer) noexcept { + tiledb_buffer_t** buffer) { return api_entry( ctx, fragment_info, serialize_type, client_side, buffer); } -int32_t tiledb_deserialize_fragment_info_request( +CAPI_INTERFACE( + deserialize_fragment_info_request, tiledb_ctx_t* ctx, const tiledb_buffer_t* buffer, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_fragment_info_t* fragment_info) noexcept { + tiledb_fragment_info_t* fragment_info) { return api_entry( ctx, buffer, serialize_type, client_side, fragment_info); } -int32_t tiledb_serialize_fragment_info( +CAPI_INTERFACE( + serialize_fragment_info, tiledb_ctx_t* ctx, const tiledb_fragment_info_t* fragment_info, tiledb_serialization_type_t serialize_type, int32_t client_side, - tiledb_buffer_t** buffer) noexcept { + tiledb_buffer_t** buffer) { return api_entry( ctx, fragment_info, serialize_type, client_side, buffer); } -int32_t tiledb_deserialize_fragment_info( +CAPI_INTERFACE( + deserialize_fragment_info, tiledb_ctx_t* ctx, const tiledb_buffer_t* buffer, tiledb_serialization_type_t serialize_type, const char* array_uri, int32_t client_side, - tiledb_fragment_info_t* fragment_info) noexcept { + tiledb_fragment_info_t* fragment_info) { return api_entry( ctx, buffer, serialize_type, array_uri, client_side, fragment_info); } -capi_return_t tiledb_handle_load_array_schema_request( +CAPI_INTERFACE( + handle_load_array_schema_request, tiledb_ctx_t* ctx, tiledb_array_t* array, tiledb_serialization_type_t serialization_type, const tiledb_buffer_t* request, - tiledb_buffer_t* response) noexcept { + tiledb_buffer_t* response) { return api_entry( ctx, array, serialization_type, request, response); } -capi_return_t tiledb_handle_load_enumerations_request( +CAPI_INTERFACE( + handle_load_enumerations_request, tiledb_ctx_t* ctx, tiledb_array_t* array, tiledb_serialization_type_t serialization_type, const tiledb_buffer_t* request, - tiledb_buffer_t* response) noexcept { + tiledb_buffer_t* response) { return api_entry( ctx, array, serialization_type, request, response); } @@ -7159,348 +7370,384 @@ int32_t tiledb::impl::tiledb_query_submit_async_func( /* FRAGMENT INFO */ /* ****************************** */ -int32_t tiledb_fragment_info_alloc( +CAPI_INTERFACE( + fragment_info_alloc, tiledb_ctx_t* ctx, const char* array_uri, - tiledb_fragment_info_t** fragment_info) noexcept { + tiledb_fragment_info_t** fragment_info) { return api_entry( ctx, array_uri, fragment_info); } -void tiledb_fragment_info_free( - tiledb_fragment_info_t** fragment_info) noexcept { +CAPI_INTERFACE_VOID( + fragment_info_free, tiledb_fragment_info_t** fragment_info) { return api_entry_void(fragment_info); } -int32_t tiledb_fragment_info_set_config( +CAPI_INTERFACE( + fragment_info_set_config, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, - tiledb_config_t* config) noexcept { + tiledb_config_t* config) { return api_entry( ctx, fragment_info, config); } -int32_t tiledb_fragment_info_get_config( +CAPI_INTERFACE( + fragment_info_get_config, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, - tiledb_config_t** config) noexcept { + tiledb_config_t** config) { return api_entry( ctx, fragment_info, config); } -int32_t tiledb_fragment_info_load( - tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info) noexcept { +CAPI_INTERFACE( + fragment_info_load, + tiledb_ctx_t* ctx, + tiledb_fragment_info_t* fragment_info) { return api_entry(ctx, fragment_info); } -int32_t tiledb_fragment_info_get_fragment_name( +CAPI_INTERFACE( + fragment_info_get_fragment_name, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, - const char** name) noexcept { + const char** name) { return api_entry( ctx, fragment_info, fid, name); } -int32_t tiledb_fragment_info_get_fragment_name_v2( +CAPI_INTERFACE( + fragment_info_get_fragment_name_v2, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, - tiledb_string_t** name) noexcept { + tiledb_string_t** name) { return api_entry( ctx, fragment_info, fid, name); } -int32_t tiledb_fragment_info_get_fragment_num( +CAPI_INTERFACE( + fragment_info_get_fragment_num, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, - uint32_t* fragment_num) noexcept { + uint32_t* fragment_num) { return api_entry( ctx, fragment_info, fragment_num); } -int32_t tiledb_fragment_info_get_fragment_uri( +CAPI_INTERFACE( + fragment_info_get_fragment_uri, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, - const char** uri) noexcept { + const char** uri) { return api_entry( ctx, fragment_info, fid, uri); } -int32_t tiledb_fragment_info_get_fragment_size( +CAPI_INTERFACE( + fragment_info_get_fragment_size, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, - uint64_t* size) noexcept { + uint64_t* size) { return api_entry( ctx, fragment_info, fid, size); } -int32_t tiledb_fragment_info_get_dense( +CAPI_INTERFACE( + fragment_info_get_dense, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, - int32_t* dense) noexcept { + int32_t* dense) { return api_entry( ctx, fragment_info, fid, dense); } -int32_t tiledb_fragment_info_get_sparse( +CAPI_INTERFACE( + fragment_info_get_sparse, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, - int32_t* sparse) noexcept { + int32_t* sparse) { return api_entry( ctx, fragment_info, fid, sparse); } -int32_t tiledb_fragment_info_get_timestamp_range( +CAPI_INTERFACE( + fragment_info_get_timestamp_range, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, uint64_t* start, - uint64_t* end) noexcept { + uint64_t* end) { return api_entry( ctx, fragment_info, fid, start, end); } -int32_t tiledb_fragment_info_get_non_empty_domain_from_index( +CAPI_INTERFACE( + fragment_info_get_non_empty_domain_from_index, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, uint32_t did, - void* domain) noexcept { + void* domain) { return api_entry< tiledb::api::tiledb_fragment_info_get_non_empty_domain_from_index>( ctx, fragment_info, fid, did, domain); } -int32_t tiledb_fragment_info_get_non_empty_domain_from_name( +CAPI_INTERFACE( + fragment_info_get_non_empty_domain_from_name, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, const char* dim_name, - void* domain) noexcept { + void* domain) { return api_entry< tiledb::api::tiledb_fragment_info_get_non_empty_domain_from_name>( ctx, fragment_info, fid, dim_name, domain); } -int32_t tiledb_fragment_info_get_non_empty_domain_var_size_from_index( +CAPI_INTERFACE( + fragment_info_get_non_empty_domain_var_size_from_index, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, uint32_t did, uint64_t* start_size, - uint64_t* end_size) noexcept { + uint64_t* end_size) { return api_entry< tiledb::api:: tiledb_fragment_info_get_non_empty_domain_var_size_from_index>( ctx, fragment_info, fid, did, start_size, end_size); } -int32_t tiledb_fragment_info_get_non_empty_domain_var_size_from_name( +CAPI_INTERFACE( + fragment_info_get_non_empty_domain_var_size_from_name, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, const char* dim_name, uint64_t* start_size, - uint64_t* end_size) noexcept { + uint64_t* end_size) { return api_entry< tiledb::api:: tiledb_fragment_info_get_non_empty_domain_var_size_from_name>( ctx, fragment_info, fid, dim_name, start_size, end_size); } -int32_t tiledb_fragment_info_get_non_empty_domain_var_from_index( +CAPI_INTERFACE( + fragment_info_get_non_empty_domain_var_from_index, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, uint32_t did, void* start, - void* end) noexcept { + void* end) { return api_entry< tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_from_index>( ctx, fragment_info, fid, did, start, end); } -int32_t tiledb_fragment_info_get_non_empty_domain_var_from_name( +CAPI_INTERFACE( + fragment_info_get_non_empty_domain_var_from_name, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, const char* dim_name, void* start, - void* end) noexcept { + void* end) { return api_entry< tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_from_name>( ctx, fragment_info, fid, dim_name, start, end); } -int32_t tiledb_fragment_info_get_mbr_num( +CAPI_INTERFACE( + fragment_info_get_mbr_num, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, - uint64_t* mbr_num) noexcept { + uint64_t* mbr_num) { return api_entry( ctx, fragment_info, fid, mbr_num); } -int32_t tiledb_fragment_info_get_mbr_from_index( +CAPI_INTERFACE( + fragment_info_get_mbr_from_index, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, uint32_t mid, uint32_t did, - void* mbr) noexcept { + void* mbr) { return api_entry( ctx, fragment_info, fid, mid, did, mbr); } -int32_t tiledb_fragment_info_get_mbr_from_name( +CAPI_INTERFACE( + fragment_info_get_mbr_from_name, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, uint32_t mid, const char* dim_name, - void* mbr) noexcept { + void* mbr) { return api_entry( ctx, fragment_info, fid, mid, dim_name, mbr); } -int32_t tiledb_fragment_info_get_mbr_var_size_from_index( +CAPI_INTERFACE( + fragment_info_get_mbr_var_size_from_index, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, uint32_t mid, uint32_t did, uint64_t* start_size, - uint64_t* end_size) noexcept { + uint64_t* end_size) { return api_entry< tiledb::api::tiledb_fragment_info_get_mbr_var_size_from_index>( ctx, fragment_info, fid, mid, did, start_size, end_size); } -int32_t tiledb_fragment_info_get_mbr_var_size_from_name( +CAPI_INTERFACE( + fragment_info_get_mbr_var_size_from_name, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, uint32_t mid, const char* dim_name, uint64_t* start_size, - uint64_t* end_size) noexcept { + uint64_t* end_size) { return api_entry< tiledb::api::tiledb_fragment_info_get_mbr_var_size_from_name>( ctx, fragment_info, fid, mid, dim_name, start_size, end_size); } -int32_t tiledb_fragment_info_get_mbr_var_from_index( +CAPI_INTERFACE( + fragment_info_get_mbr_var_from_index, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, uint32_t mid, uint32_t did, void* start, - void* end) noexcept { + void* end) { return api_entry( ctx, fragment_info, fid, mid, did, start, end); } -int32_t tiledb_fragment_info_get_mbr_var_from_name( +CAPI_INTERFACE( + fragment_info_get_mbr_var_from_name, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, uint32_t mid, const char* dim_name, void* start, - void* end) noexcept { + void* end) { return api_entry( ctx, fragment_info, fid, mid, dim_name, start, end); } -int32_t tiledb_fragment_info_get_cell_num( +CAPI_INTERFACE( + fragment_info_get_cell_num, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, - uint64_t* cell_num) noexcept { + uint64_t* cell_num) { return api_entry( ctx, fragment_info, fid, cell_num); } -int32_t tiledb_fragment_info_get_total_cell_num( +CAPI_INTERFACE( + fragment_info_get_total_cell_num, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, - uint64_t* cell_num) noexcept { + uint64_t* cell_num) { return api_entry( ctx, fragment_info, cell_num); } -int32_t tiledb_fragment_info_get_version( +CAPI_INTERFACE( + fragment_info_get_version, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, - uint32_t* version) noexcept { + uint32_t* version) { return api_entry( ctx, fragment_info, fid, version); } -int32_t tiledb_fragment_info_has_consolidated_metadata( +CAPI_INTERFACE( + fragment_info_has_consolidated_metadata, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, - int32_t* has) noexcept { + int32_t* has) { return api_entry( ctx, fragment_info, fid, has); } -int32_t tiledb_fragment_info_get_unconsolidated_metadata_num( +CAPI_INTERFACE( + fragment_info_get_unconsolidated_metadata_num, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, - uint32_t* unconsolidated) noexcept { + uint32_t* unconsolidated) { return api_entry< tiledb::api::tiledb_fragment_info_get_unconsolidated_metadata_num>( ctx, fragment_info, unconsolidated); } -int32_t tiledb_fragment_info_get_to_vacuum_num( +CAPI_INTERFACE( + fragment_info_get_to_vacuum_num, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, - uint32_t* to_vacuum_num) noexcept { + uint32_t* to_vacuum_num) { return api_entry( ctx, fragment_info, to_vacuum_num); } -int32_t tiledb_fragment_info_get_to_vacuum_uri( +CAPI_INTERFACE( + fragment_info_get_to_vacuum_uri, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, - const char** uri) noexcept { + const char** uri) { return api_entry( ctx, fragment_info, fid, uri); } -int32_t tiledb_fragment_info_get_array_schema( +CAPI_INTERFACE( + fragment_info_get_array_schema, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, - tiledb_array_schema_t** array_schema) noexcept { + tiledb_array_schema_t** array_schema) { return api_entry( ctx, fragment_info, fid, array_schema); } -int32_t tiledb_fragment_info_get_array_schema_name( +CAPI_INTERFACE( + fragment_info_get_array_schema_name, tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, uint32_t fid, - const char** schema_name) noexcept { + const char** schema_name) { return api_entry( ctx, fragment_info, fid, schema_name); } -int32_t tiledb_fragment_info_dump( +CAPI_INTERFACE( + fragment_info_dump, tiledb_ctx_t* ctx, const tiledb_fragment_info_t* fragment_info, - FILE* out) noexcept { + FILE* out) { return api_entry( ctx, fragment_info, out); } @@ -7509,65 +7756,71 @@ int32_t tiledb_fragment_info_dump( /* EXPERIMENTAL APIs */ /* ********************************* */ -TILEDB_EXPORT int32_t tiledb_query_get_status_details( +CAPI_INTERFACE( + query_get_status_details, tiledb_ctx_t* ctx, tiledb_query_t* query, - tiledb_query_status_details_t* status) noexcept { + tiledb_query_status_details_t* status) { return api_entry( ctx, query, status); } -int32_t tiledb_consolidation_plan_create_with_mbr( +CAPI_INTERFACE( + consolidation_plan_create_with_mbr, tiledb_ctx_t* ctx, tiledb_array_t* array, uint64_t fragment_size, - tiledb_consolidation_plan_t** consolidation_plan) noexcept { + tiledb_consolidation_plan_t** consolidation_plan) { return api_entry( ctx, array, fragment_size, consolidation_plan); } -void tiledb_consolidation_plan_free( - tiledb_consolidation_plan_t** consolidation_plan) noexcept { +CAPI_INTERFACE_VOID( + consolidation_plan_free, tiledb_consolidation_plan_t** consolidation_plan) { return api_entry_void( consolidation_plan); } -int32_t tiledb_consolidation_plan_get_num_nodes( +CAPI_INTERFACE( + consolidation_plan_get_num_nodes, tiledb_ctx_t* ctx, tiledb_consolidation_plan_t* consolidation_plan, - uint64_t* num_nodes) noexcept { + uint64_t* num_nodes) { return api_entry( ctx, consolidation_plan, num_nodes); } -int32_t tiledb_consolidation_plan_get_num_fragments( +CAPI_INTERFACE( + consolidation_plan_get_num_fragments, tiledb_ctx_t* ctx, tiledb_consolidation_plan_t* consolidation_plan, uint64_t node_index, - uint64_t* num_fragments) noexcept { + uint64_t* num_fragments) { return api_entry( ctx, consolidation_plan, node_index, num_fragments); } -int32_t tiledb_consolidation_plan_get_fragment_uri( +CAPI_INTERFACE( + consolidation_plan_get_fragment_uri, tiledb_ctx_t* ctx, tiledb_consolidation_plan_t* consolidation_plan, uint64_t node_index, uint64_t fragment_index, - const char** uri) noexcept { + const char** uri) { return api_entry( ctx, consolidation_plan, node_index, fragment_index, uri); } -int32_t tiledb_consolidation_plan_dump_json_str( +CAPI_INTERFACE( + consolidation_plan_dump_json_str, tiledb_ctx_t* ctx, const tiledb_consolidation_plan_t* consolidation_plan, - char** out) noexcept { + char** out) { return api_entry( ctx, consolidation_plan, out); } -int32_t tiledb_consolidation_plan_free_json_str(char** out) noexcept { +CAPI_INTERFACE(consolidation_plan_free_json_str, char** out) { return api_entry_plain( out); } diff --git a/tiledb/sm/c_api/tiledb_dimension_label.cc b/tiledb/sm/c_api/tiledb_dimension_label.cc index 5db966e77e2..dfab3f8c32c 100644 --- a/tiledb/sm/c_api/tiledb_dimension_label.cc +++ b/tiledb/sm/c_api/tiledb_dimension_label.cc @@ -35,9 +35,7 @@ #include "tiledb/sm/c_api/tiledb.h" #include "tiledb/sm/c_api/tiledb_dimension_label_experimental.h" -using namespace tiledb::common; - -namespace tiledb::common::detail { +namespace tiledb::api { capi_return_t tiledb_array_schema_add_dimension_label( tiledb_ctx_t* ctx, @@ -204,7 +202,7 @@ capi_return_t tiledb_subarray_has_label_ranges( return TILEDB_OK; } -} // namespace tiledb::common::detail +} // namespace tiledb::api using tiledb::api::api_entry_context; using tiledb::api::api_entry_with_context; @@ -212,153 +210,173 @@ using tiledb::api::api_entry_with_context; template constexpr auto api_entry = tiledb::api::api_entry_with_context; -capi_return_t tiledb_array_schema_add_dimension_label( +CAPI_INTERFACE( + array_schema_add_dimension_label, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, const uint32_t dim_index, const char* name, tiledb_data_order_t label_order, - tiledb_datatype_t label_type) noexcept { - return api_entry( + tiledb_datatype_t label_type) { + return api_entry( ctx, array_schema, dim_index, name, label_order, label_type); } -capi_return_t tiledb_array_schema_get_dimension_label_from_name( +CAPI_INTERFACE( + array_schema_get_dimension_label_from_name, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, const char* label_name, - tiledb_dimension_label_t** dim_label) noexcept { + tiledb_dimension_label_t** dim_label) { return api_entry_with_context< - detail::tiledb_array_schema_get_dimension_label_from_name>( + tiledb::api::tiledb_array_schema_get_dimension_label_from_name>( ctx, array_schema, label_name, dim_label); } -capi_return_t tiledb_array_schema_has_dimension_label( +CAPI_INTERFACE( + array_schema_has_dimension_label, tiledb_ctx_t* ctx, const tiledb_array_schema_t* array_schema, const char* name, - int32_t* has_dim_label) noexcept { - return api_entry_context( + int32_t* has_dim_label) { + return api_entry_context< + tiledb::api::tiledb_array_schema_has_dimension_label>( ctx, array_schema, name, has_dim_label); } -capi_return_t tiledb_array_schema_set_dimension_label_filter_list( +CAPI_INTERFACE( + array_schema_set_dimension_label_filter_list, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, const char* label_name, - tiledb_filter_list_t* filter_list) noexcept { - return api_entry( + tiledb_filter_list_t* filter_list) { + return api_entry< + tiledb::api::tiledb_array_schema_set_dimension_label_filter_list>( ctx, array_schema, label_name, filter_list); } -capi_return_t tiledb_array_schema_set_dimension_label_tile_extent( +CAPI_INTERFACE( + array_schema_set_dimension_label_tile_extent, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, const char* label_name, tiledb_datatype_t type, - const void* tile_extent) noexcept { - return api_entry( + const void* tile_extent) { + return api_entry< + tiledb::api::tiledb_array_schema_set_dimension_label_tile_extent>( ctx, array_schema, label_name, type, tile_extent); } -capi_return_t tiledb_array_schema_get_dimension_label_num( +CAPI_INTERFACE( + array_schema_get_dimension_label_num, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, - uint64_t* dim_label_num) noexcept { - return api_entry_context( + uint64_t* dim_label_num) { + return api_entry_context< + tiledb::api::tiledb_array_schema_get_dimension_label_num>( ctx, array_schema, dim_label_num); } -capi_return_t tiledb_array_schema_get_dimension_label_from_index( +CAPI_INTERFACE( + array_schema_get_dimension_label_from_index, tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, uint64_t dim_label_index, - tiledb_dimension_label_t** dim_label) noexcept { + tiledb_dimension_label_t** dim_label) { return api_entry_context< - detail::tiledb_array_schema_get_dimension_label_from_index>( + tiledb::api::tiledb_array_schema_get_dimension_label_from_index>( ctx, array_schema, dim_label_index, dim_label); } -capi_return_t tiledb_subarray_add_label_range( +CAPI_INTERFACE( + subarray_add_label_range, tiledb_ctx_t* ctx, tiledb_subarray_t* subarray, const char* label_name, const void* start, const void* end, - const void* stride) noexcept { - return api_entry_context( + const void* stride) { + return api_entry_context( ctx, subarray, label_name, start, end, stride); } -capi_return_t tiledb_subarray_add_label_range_var( +CAPI_INTERFACE( + subarray_add_label_range_var, tiledb_ctx_t* ctx, tiledb_subarray_t* subarray, const char* label_name, const void* start, uint64_t start_size, const void* end, - uint64_t end_size) noexcept { - return api_entry_context( + uint64_t end_size) { + return api_entry_context( ctx, subarray, label_name, start, start_size, end, end_size); } -capi_return_t tiledb_subarray_get_label_name( +CAPI_INTERFACE( + subarray_get_label_name, tiledb_ctx_t* ctx, tiledb_subarray_t* subarray, uint32_t dim_idx, - const char** label_name) noexcept { - return api_entry_context( + const char** label_name) { + return api_entry_context( ctx, subarray, dim_idx, label_name); } -capi_return_t tiledb_subarray_get_label_range( +CAPI_INTERFACE( + subarray_get_label_range, tiledb_ctx_t* ctx, const tiledb_subarray_t* subarray, const char* dim_name, uint64_t range_idx, const void** start, const void** end, - const void** stride) noexcept { - return api_entry_context( + const void** stride) { + return api_entry_context( ctx, subarray, dim_name, range_idx, start, end, stride); } -capi_return_t tiledb_subarray_get_label_range_num( +CAPI_INTERFACE( + subarray_get_label_range_num, tiledb_ctx_t* ctx, const tiledb_subarray_t* subarray, const char* dim_name, - uint64_t* range_num) noexcept { - return api_entry_context( + uint64_t* range_num) { + return api_entry_context( ctx, subarray, dim_name, range_num); } -capi_return_t tiledb_subarray_get_label_range_var( +CAPI_INTERFACE( + subarray_get_label_range_var, tiledb_ctx_t* ctx, const tiledb_subarray_t* subarray, const char* dim_name, uint64_t range_idx, void* start, - void* end) noexcept { - return api_entry_context( + void* end) { + return api_entry_context( ctx, subarray, dim_name, range_idx, start, end); } -capi_return_t tiledb_subarray_get_label_range_var_size( +CAPI_INTERFACE( + subarray_get_label_range_var_size, tiledb_ctx_t* ctx, const tiledb_subarray_t* subarray, const char* dim_name, uint64_t range_idx, uint64_t* start_size, - uint64_t* end_size) noexcept { - return api_entry_context( + uint64_t* end_size) { + return api_entry_context< + tiledb::api::tiledb_subarray_get_label_range_var_size>( ctx, subarray, dim_name, range_idx, start_size, end_size); } -capi_return_t tiledb_subarray_has_label_ranges( +CAPI_INTERFACE( + subarray_has_label_ranges, tiledb_ctx_t* ctx, const tiledb_subarray_t* subarray, const uint32_t dim_idx, - int32_t* has_label_ranges) noexcept { - return api_entry_context( + int32_t* has_label_ranges) { + return api_entry_context( ctx, subarray, dim_idx, has_label_ranges); } diff --git a/tiledb/sm/c_api/tiledb_experimental.h b/tiledb/sm/c_api/tiledb_experimental.h index a814a34043e..dff9497d270 100644 --- a/tiledb/sm/c_api/tiledb_experimental.h +++ b/tiledb/sm/c_api/tiledb_experimental.h @@ -75,7 +75,7 @@ extern "C" { * @return `TILEDB_OK` for success and `TILEDB_ERR` for error. */ TILEDB_EXPORT capi_return_t -tiledb_log_warn(tiledb_ctx_t* ctx, const char* message); +tiledb_log_warn(tiledb_ctx_t* ctx, const char* message) TILEDB_NOEXCEPT; /* ********************************* */ /* AS BUILT */ diff --git a/tiledb/sm/c_api/tiledb_filestore.cc b/tiledb/sm/c_api/tiledb_filestore.cc index d659eafe509..9c0a38342a5 100644 --- a/tiledb/sm/c_api/tiledb_filestore.cc +++ b/tiledb/sm/c_api/tiledb_filestore.cc @@ -62,7 +62,7 @@ #include "tiledb/sm/subarray/subarray.h" #include "tiledb/type/range/range.h" -namespace tiledb::common::detail { +namespace tiledb::api { // Forward declarations uint64_t compute_tile_extent_based_on_file_size(uint64_t file_size); @@ -809,69 +809,78 @@ uint64_t get_buffer_size_from_config( return buffer_size; } -} // namespace tiledb::common::detail +} // namespace tiledb::api using tiledb::api::api_entry_plain; template constexpr auto api_entry = tiledb::api::api_entry_with_context; -int32_t tiledb_filestore_schema_create( +CAPI_INTERFACE( + filestore_schema_create, tiledb_ctx_t* ctx, const char* uri, - tiledb_array_schema_t** array_schema) noexcept { - return api_entry( + tiledb_array_schema_t** array_schema) { + return api_entry( ctx, uri, array_schema); } -int32_t tiledb_filestore_uri_import( +CAPI_INTERFACE( + filestore_uri_import, tiledb_ctx_t* ctx, const char* filestore_array_uri, const char* file_uri, - tiledb_mime_type_t mime_type) noexcept { - return api_entry( + tiledb_mime_type_t mime_type) { + return api_entry( ctx, filestore_array_uri, file_uri, mime_type); } -int32_t tiledb_filestore_uri_export( +CAPI_INTERFACE( + filestore_uri_export, tiledb_ctx_t* ctx, const char* file_uri, - const char* filestore_array_uri) noexcept { - return api_entry( + const char* filestore_array_uri) { + return api_entry( ctx, file_uri, filestore_array_uri); } -int32_t tiledb_filestore_buffer_import( +CAPI_INTERFACE( + filestore_buffer_import, tiledb_ctx_t* ctx, const char* filestore_array_uri, void* buf, size_t size, - tiledb_mime_type_t mime_type) noexcept { - return api_entry( + tiledb_mime_type_t mime_type) { + return api_entry( ctx, filestore_array_uri, buf, size, mime_type); } -int32_t tiledb_filestore_buffer_export( +CAPI_INTERFACE( + filestore_buffer_export, tiledb_ctx_t* ctx, const char* filestore_array_uri, size_t offset, void* buf, - size_t size) noexcept { - return api_entry( + size_t size) { + return api_entry( ctx, filestore_array_uri, offset, buf, size); } -int32_t tiledb_filestore_size( - tiledb_ctx_t* ctx, const char* filestore_array_uri, size_t* size) noexcept { - return api_entry( +CAPI_INTERFACE( + filestore_size, + tiledb_ctx_t* ctx, + const char* filestore_array_uri, + size_t* size) { + return api_entry( ctx, filestore_array_uri, size); } -int32_t tiledb_mime_type_to_str( - tiledb_mime_type_t mime_type, const char** str) noexcept { - return api_entry_plain(mime_type, str); +CAPI_INTERFACE( + mime_type_to_str, tiledb_mime_type_t mime_type, const char** str) { + return api_entry_plain(mime_type, str); } -int32_t tiledb_mime_type_from_str( - const char* str, tiledb_mime_type_t* mime_type) noexcept { - return api_entry_plain(str, mime_type); -} \ No newline at end of file +CAPI_INTERFACE( + mime_type_from_str, const char* str, tiledb_mime_type_t* mime_type) { + return api_entry_plain( + str, mime_type); +}