opendal.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
 
#ifndef _OPENDAL_H
#define _OPENDAL_H
 
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
 
#define OPENDAL_SEEK_SET 0
 
#define OPENDAL_SEEK_CUR 1
 
#define OPENDAL_SEEK_END 2
 
typedef enum opendal_code {
  OPENDAL_UNEXPECTED,
  OPENDAL_UNSUPPORTED,
  OPENDAL_CONFIG_INVALID,
  OPENDAL_NOT_FOUND,
  OPENDAL_PERMISSION_DENIED,
  OPENDAL_IS_A_DIRECTORY,
  OPENDAL_NOT_A_DIRECTORY,
  OPENDAL_ALREADY_EXISTS,
  OPENDAL_RATE_LIMITED,
  OPENDAL_IS_SAME_FILE,
  OPENDAL_CONDITION_NOT_MATCH,
  OPENDAL_RANGE_NOT_SATISFIED,
  OPENDAL_CONFLICT,
} opendal_code;
 
typedef struct opendal_presigned_request_inner opendal_presigned_request_inner;
 
typedef struct opendal_bytes {
  uint8_t *data;
  uintptr_t len;
  uintptr_t capacity;
} opendal_bytes;
 
typedef struct opendal_error {
  enum opendal_code code;
  struct opendal_bytes message;
} opendal_error;
 
typedef struct opendal_entry {
  void *inner;
} opendal_entry;
 
typedef struct opendal_result_lister_next {
  struct opendal_entry *entry;
  struct opendal_error *error;
} opendal_result_lister_next;
 
typedef struct opendal_lister {
  void *inner;
} opendal_lister;
 
typedef struct opendal_operator_layers {
  void *inner;
} opendal_operator_layers;
 
typedef struct opendal_metadata {
  void *inner;
} opendal_metadata;
 
typedef struct opendal_metadata_user_metadata {
  void *inner;
} opendal_metadata_user_metadata;
 
typedef struct opendal_metadata_user_metadata_pair {
  const char *key;
  const char *value;
} opendal_metadata_user_metadata_pair;
 
typedef struct opendal_operator {
  void *inner;
} opendal_operator;
 
typedef struct opendal_result_operator_new {
  struct opendal_operator *op;
  struct opendal_error *error;
} opendal_result_operator_new;
 
typedef struct opendal_operator_options {
  void *inner;
} opendal_operator_options;
 
typedef struct opendal_write_user_metadata_pair {
  const char *key;
  const char *value;
} opendal_write_user_metadata_pair;
 
typedef struct opendal_write_options {
  bool append;
  const char *cache_control;
  const char *content_type;
  const char *content_disposition;
  const char *content_encoding;
  const char *if_match;
  const char *if_none_match;
  bool if_not_exists;
  uintptr_t concurrent;
  bool has_chunk;
  uintptr_t chunk;
  const struct opendal_write_user_metadata_pair *user_metadata;
  uintptr_t user_metadata_len;
} opendal_write_options;
 
typedef struct opendal_result_write {
  struct opendal_metadata *meta;
  struct opendal_error *error;
} opendal_result_write;
 
typedef struct opendal_result_read {
  struct opendal_bytes data;
  struct opendal_error *error;
} opendal_result_read;
 
typedef struct opendal_read_options {
  uint64_t offset;
  bool has_length;
  uint64_t length;
  const char *version;
  const char *if_match;
  const char *if_none_match;
  bool has_if_modified_since;
  int64_t if_modified_since;
  bool has_if_unmodified_since;
  int64_t if_unmodified_since;
  uintptr_t concurrent;
  bool has_chunk;
  uintptr_t chunk;
  bool has_gap;
  uintptr_t gap;
  bool has_content_length_hint;
  uint64_t content_length_hint;
  const char *override_content_type;
  const char *override_cache_control;
  const char *override_content_disposition;
} opendal_read_options;
 
typedef struct opendal_reader {
  void *inner;
} opendal_reader;
 
typedef struct opendal_result_operator_reader {
  struct opendal_reader *reader;
  struct opendal_error *error;
} opendal_result_operator_reader;
 
typedef struct opendal_reader_options {
  const char *version;
  const char *if_match;
  const char *if_none_match;
  bool has_if_modified_since;
  int64_t if_modified_since;
  bool has_if_unmodified_since;
  int64_t if_unmodified_since;
  bool has_content_length_hint;
  uint64_t content_length_hint;
  uintptr_t concurrent;
  bool has_chunk;
  uintptr_t chunk;
  bool has_gap;
  uintptr_t gap;
  uintptr_t prefetch;
} opendal_reader_options;
 
typedef struct opendal_writer {
  void *inner;
} opendal_writer;
 
typedef struct opendal_result_operator_writer {
  struct opendal_writer *writer;
  struct opendal_error *error;
} opendal_result_operator_writer;
 
typedef struct opendal_delete_options {
  char *version;
  bool recursive;
} opendal_delete_options;
 
typedef struct opendal_result_is_exist {
  bool is_exist;
  struct opendal_error *error;
} opendal_result_is_exist;
 
typedef struct opendal_result_exists {
  bool exists;
  struct opendal_error *error;
} opendal_result_exists;
 
typedef struct opendal_result_stat {
  struct opendal_metadata *meta;
  struct opendal_error *error;
} opendal_result_stat;
 
typedef struct opendal_stat_options {
  const char *version;
  const char *if_match;
  const char *if_none_match;
  bool has_if_modified_since;
  int64_t if_modified_since;
  bool has_if_unmodified_since;
  int64_t if_unmodified_since;
  const char *override_content_type;
  const char *override_cache_control;
  const char *override_content_disposition;
} opendal_stat_options;
 
typedef struct opendal_result_list {
  struct opendal_lister *lister;
  struct opendal_error *error;
} opendal_result_list;
 
typedef struct opendal_list_options {
  bool recursive;
  uintptr_t limit;
  char *start_after;
  bool versions;
  bool deleted;
} opendal_list_options;
 
typedef struct opendal_copy_options {
  bool if_not_exists;
  const char *if_match;
  const char *source_version;
  bool has_source_content_length_hint;
  uint64_t source_content_length_hint;
  uintptr_t concurrent;
  bool has_chunk;
  uintptr_t chunk;
} opendal_copy_options;
 
typedef struct opendal_copier {
  void *inner;
} opendal_copier;
 
typedef struct opendal_result_operator_copier {
  struct opendal_copier *copier;
  struct opendal_error *error;
} opendal_result_operator_copier;
 
typedef struct opendal_operator_info {
  void *inner;
} opendal_operator_info;
 
typedef struct opendal_capability {
  bool stat;
  bool stat_with_if_match;
  bool stat_with_if_none_match;
  bool stat_with_if_modified_since;
  bool stat_with_if_unmodified_since;
  bool stat_with_override_cache_control;
  bool stat_with_override_content_disposition;
  bool stat_with_override_content_type;
  bool stat_with_version;
  bool read;
  bool read_with_if_match;
  bool read_with_if_none_match;
  bool read_with_override_cache_control;
  bool read_with_override_content_disposition;
  bool read_with_override_content_type;
  bool read_with_if_modified_since;
  bool read_with_if_unmodified_since;
  bool read_with_version;
  bool write;
  bool write_can_multi;
  bool write_can_empty;
  bool write_can_append;
  bool write_with_content_type;
  bool write_with_content_disposition;
  bool write_with_content_encoding;
  bool write_with_cache_control;
  bool write_with_if_match;
  bool write_with_if_none_match;
  bool write_with_if_not_exists;
  bool write_with_user_metadata;
  uintptr_t write_multi_max_size;
  uintptr_t write_multi_min_size;
  uintptr_t write_total_max_size;
  bool create_dir;
  bool delete_;
  bool delete_with_version;
  bool delete_with_recursive;
  bool copy;
  bool copy_with_if_not_exists;
  bool copy_with_if_match;
  bool copy_with_source_version;
  bool copy_can_multi;
  uintptr_t copy_multi_max_size;
  uintptr_t copy_multi_min_size;
  bool rename;
  bool list;
  bool list_with_limit;
  bool list_with_start_after;
  bool list_with_recursive;
  bool list_with_versions;
  bool list_with_deleted;
  bool presign;
  bool presign_read;
  bool presign_stat;
  bool presign_write;
  bool presign_delete;
  bool shared;
} opendal_capability;
 
typedef struct opendal_presigned_request {
  struct opendal_presigned_request_inner *inner;
} opendal_presigned_request;
 
typedef struct opendal_result_presign {
  struct opendal_presigned_request *req;
  struct opendal_error *error;
} opendal_result_presign;
 
typedef struct opendal_http_header_pair {
  const char *key;
  const char *value;
} opendal_http_header_pair;
 
typedef struct opendal_result_reader_read {
  uintptr_t size;
  struct opendal_error *error;
} opendal_result_reader_read;
 
typedef struct opendal_result_reader_seek {
  uint64_t pos;
  struct opendal_error *error;
} opendal_result_reader_seek;
 
typedef struct opendal_result_writer_write {
  uintptr_t size;
  struct opendal_error *error;
} opendal_result_writer_write;
 
typedef struct opendal_result_copier_next {
  uintptr_t size;
  bool has_next;
  struct opendal_error *error;
} opendal_result_copier_next;
 
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
 
void opendal_error_free(struct opendal_error *ptr);
 
struct opendal_result_lister_next opendal_lister_next(struct opendal_lister *self);
 
void opendal_lister_free(struct opendal_lister *ptr);
 
struct opendal_operator_layers *opendal_operator_layers_new(void);
 
void opendal_operator_layers_add_retry(struct opendal_operator_layers *self,
                                       bool jitter,
                                       float factor,
                                       uint64_t min_delay_ns,
                                       uint64_t max_delay_ns,
                                       uint64_t max_times);
 
void opendal_operator_layers_add_timeout(struct opendal_operator_layers *self,
                                         uint64_t timeout_ns,
                                         uint64_t io_timeout_ns);
 
void opendal_operator_layers_free(struct opendal_operator_layers *ptr);
 
void opendal_metadata_free(struct opendal_metadata *ptr);
 
uint8_t opendal_metadata_mode(const struct opendal_metadata *self);
 
uint64_t opendal_metadata_content_length(const struct opendal_metadata *self);
 
bool opendal_metadata_is_file(const struct opendal_metadata *self);
 
bool opendal_metadata_is_dir(const struct opendal_metadata *self);
 
uint8_t opendal_metadata_is_current(const struct opendal_metadata *self);
 
bool opendal_metadata_is_deleted(const struct opendal_metadata *self);
 
char *opendal_metadata_cache_control(const struct opendal_metadata *self);
 
char *opendal_metadata_content_disposition(const struct opendal_metadata *self);
 
char *opendal_metadata_content_md5(const struct opendal_metadata *self);
 
char *opendal_metadata_content_type(const struct opendal_metadata *self);
 
char *opendal_metadata_content_encoding(const struct opendal_metadata *self);
 
char *opendal_metadata_etag(const struct opendal_metadata *self);
 
char *opendal_metadata_version(const struct opendal_metadata *self);
 
struct opendal_metadata_user_metadata *opendal_metadata_get_user_metadata(const struct opendal_metadata *self);
 
int64_t opendal_metadata_last_modified_ms(const struct opendal_metadata *self);
 
const struct opendal_metadata_user_metadata_pair *opendal_metadata_user_metadata_pairs(const struct opendal_metadata_user_metadata *metadata);
 
uintptr_t opendal_metadata_user_metadata_len(const struct opendal_metadata_user_metadata *metadata);
 
void opendal_metadata_user_metadata_free(struct opendal_metadata_user_metadata *metadata);
 
void opendal_operator_free(const struct opendal_operator *ptr);
 
struct opendal_result_operator_new opendal_operator_new(const char *scheme,
                                                        const struct opendal_operator_options *options);
 
struct opendal_result_operator_new opendal_operator_new_with_layers(const char *scheme,
                                                                    const struct opendal_operator_options *options,
                                                                    const struct opendal_operator_layers *layers);
 
struct opendal_error *opendal_operator_write(const struct opendal_operator *op,
                                             const char *path,
                                             const struct opendal_bytes *bytes);
 
struct opendal_error *opendal_operator_write_with(const struct opendal_operator *op,
                                                  const char *path,
                                                  const struct opendal_bytes *bytes,
                                                  const struct opendal_write_options *opts);
 
struct opendal_result_write opendal_operator_write_with_metadata(const struct opendal_operator *op,
                                                                 const char *path,
                                                                 const struct opendal_bytes *bytes,
                                                                 const struct opendal_write_options *opts);
 
struct opendal_result_read opendal_operator_read(const struct opendal_operator *op,
                                                 const char *path);
 
struct opendal_result_read opendal_operator_read_with(const struct opendal_operator *op,
                                                      const char *path,
                                                      const struct opendal_read_options *opts);
 
struct opendal_result_operator_reader opendal_operator_reader(const struct opendal_operator *op,
                                                              const char *path);
 
struct opendal_result_operator_reader opendal_operator_reader_with(const struct opendal_operator *op,
                                                                   const char *path,
                                                                   const struct opendal_reader_options *opts);
 
struct opendal_result_operator_writer opendal_operator_writer(const struct opendal_operator *op,
                                                              const char *path);
 
struct opendal_result_operator_writer opendal_operator_writer_with(const struct opendal_operator *op,
                                                                   const char *path,
                                                                   const struct opendal_write_options *opts);
 
struct opendal_error *opendal_operator_delete(const struct opendal_operator *op, const char *path);
 
struct opendal_error *opendal_operator_delete_with(const struct opendal_operator *op,
                                                   const char *path,
                                                   const struct opendal_delete_options *opts);
 
struct opendal_result_is_exist opendal_operator_is_exist(const struct opendal_operator *op,
                                                         const char *path);
 
struct opendal_result_exists opendal_operator_exists(const struct opendal_operator *op,
                                                     const char *path);
 
struct opendal_result_stat opendal_operator_stat(const struct opendal_operator *op,
                                                 const char *path);
 
struct opendal_result_stat opendal_operator_stat_with(const struct opendal_operator *op,
                                                      const char *path,
                                                      const struct opendal_stat_options *opts);
 
struct opendal_result_list opendal_operator_list(const struct opendal_operator *op,
                                                 const char *path);
 
struct opendal_result_list opendal_operator_list_with(const struct opendal_operator *op,
                                                      const char *path,
                                                      const struct opendal_list_options *opts);
 
struct opendal_error *opendal_operator_create_dir(const struct opendal_operator *op,
                                                  const char *path);
 
struct opendal_error *opendal_operator_rename(const struct opendal_operator *op,
                                              const char *src,
                                              const char *dest);
 
struct opendal_error *opendal_operator_copy(const struct opendal_operator *op,
                                            const char *src,
                                            const char *dest);
 
struct opendal_error *opendal_operator_copy_with(const struct opendal_operator *op,
                                                 const char *src,
                                                 const char *dest,
                                                 const struct opendal_copy_options *opts);
 
struct opendal_error *opendal_operator_check(const struct opendal_operator *op);
 
struct opendal_result_operator_copier opendal_operator_copier(const struct opendal_operator *op,
                                                              const char *src,
                                                              const char *dest);
 
struct opendal_result_operator_copier opendal_operator_copier_with(const struct opendal_operator *op,
                                                                   const char *src,
                                                                   const char *dest,
                                                                   const struct opendal_copy_options *opts);
 
struct opendal_operator_info *opendal_operator_info_new(const struct opendal_operator *op);
 
void opendal_operator_info_free(struct opendal_operator_info *ptr);
 
char *opendal_operator_info_get_scheme(const struct opendal_operator_info *self);
 
char *opendal_operator_info_get_root(const struct opendal_operator_info *self);
 
char *opendal_operator_info_get_name(const struct opendal_operator_info *self);
 
struct opendal_capability opendal_operator_info_get_capability(const struct opendal_operator_info *self);
 
struct opendal_result_presign opendal_operator_presign_read(const struct opendal_operator *op,
                                                            const char *path,
                                                            uint64_t expire_secs);
 
struct opendal_result_presign opendal_operator_presign_read_with(const struct opendal_operator *op,
                                                                 const char *path,
                                                                 uint64_t expire_secs,
                                                                 const struct opendal_read_options *opts);
 
struct opendal_result_presign opendal_operator_presign_write(const struct opendal_operator *op,
                                                             const char *path,
                                                             uint64_t expire_secs);
 
struct opendal_result_presign opendal_operator_presign_write_with(const struct opendal_operator *op,
                                                                  const char *path,
                                                                  uint64_t expire_secs,
                                                                  const struct opendal_write_options *opts);
 
struct opendal_result_presign opendal_operator_presign_delete(const struct opendal_operator *op,
                                                              const char *path,
                                                              uint64_t expire_secs);
 
struct opendal_result_presign opendal_operator_presign_delete_with(const struct opendal_operator *op,
                                                                   const char *path,
                                                                   uint64_t expire_secs,
                                                                   const struct opendal_delete_options *opts);
 
struct opendal_result_presign opendal_operator_presign_stat(const struct opendal_operator *op,
                                                            const char *path,
                                                            uint64_t expire_secs);
 
struct opendal_result_presign opendal_operator_presign_stat_with(const struct opendal_operator *op,
                                                                 const char *path,
                                                                 uint64_t expire_secs,
                                                                 const struct opendal_stat_options *opts);
 
const char *opendal_presigned_request_method(const struct opendal_presigned_request *req);
 
const char *opendal_presigned_request_uri(const struct opendal_presigned_request *req);
 
const struct opendal_http_header_pair *opendal_presigned_request_headers(const struct opendal_presigned_request *req);
 
uintptr_t opendal_presigned_request_headers_len(const struct opendal_presigned_request *req);
 
void opendal_presigned_request_free(struct opendal_presigned_request *req);
 
void opendal_string_free(char *ptr);
 
void opendal_bytes_free(struct opendal_bytes *ptr);
 
struct opendal_list_options *opendal_list_options_new(void);
 
void opendal_list_options_set_recursive(struct opendal_list_options *opts, bool recursive);
 
void opendal_list_options_set_limit(struct opendal_list_options *opts, uintptr_t limit);
 
void opendal_list_options_set_start_after(struct opendal_list_options *opts,
                                          const char *start_after);
 
void opendal_list_options_set_versions(struct opendal_list_options *opts, bool versions);
 
void opendal_list_options_set_deleted(struct opendal_list_options *opts, bool deleted);
 
void opendal_list_options_free(struct opendal_list_options *opts);
 
struct opendal_delete_options *opendal_delete_options_new(void);
 
void opendal_delete_options_set_version(struct opendal_delete_options *opts, const char *version);
 
void opendal_delete_options_set_recursive(struct opendal_delete_options *opts, bool recursive);
 
void opendal_delete_options_free(struct opendal_delete_options *opts);
 
struct opendal_write_options *opendal_write_options_new(void);
 
void opendal_write_options_free(struct opendal_write_options *opts);
 
void opendal_write_options_set_append(struct opendal_write_options *opts, bool append);
 
void opendal_write_options_set_cache_control(struct opendal_write_options *opts,
                                             const char *cache_control);
 
void opendal_write_options_set_content_type(struct opendal_write_options *opts,
                                            const char *content_type);
 
void opendal_write_options_set_content_disposition(struct opendal_write_options *opts,
                                                   const char *content_disposition);
 
void opendal_write_options_set_content_encoding(struct opendal_write_options *opts,
                                                const char *content_encoding);
 
void opendal_write_options_set_if_match(struct opendal_write_options *opts, const char *if_match);
 
void opendal_write_options_set_if_none_match(struct opendal_write_options *opts,
                                             const char *if_none_match);
 
void opendal_write_options_set_if_not_exists(struct opendal_write_options *opts,
                                             bool if_not_exists);
 
void opendal_write_options_set_concurrent(struct opendal_write_options *opts, uintptr_t concurrent);
 
void opendal_write_options_set_chunk(struct opendal_write_options *opts, uintptr_t chunk);
 
void opendal_write_options_set_user_metadata(struct opendal_write_options *opts,
                                             const struct opendal_write_user_metadata_pair *pairs,
                                             uintptr_t len);
 
struct opendal_stat_options *opendal_stat_options_new(void);
 
void opendal_stat_options_free(struct opendal_stat_options *opts);
 
void opendal_stat_options_set_version(struct opendal_stat_options *opts, const char *version);
 
void opendal_stat_options_set_if_match(struct opendal_stat_options *opts, const char *if_match);
 
void opendal_stat_options_set_if_none_match(struct opendal_stat_options *opts,
                                            const char *if_none_match);
 
void opendal_stat_options_set_if_modified_since(struct opendal_stat_options *opts,
                                                int64_t if_modified_since);
 
void opendal_stat_options_set_if_unmodified_since(struct opendal_stat_options *opts,
                                                  int64_t if_unmodified_since);
 
void opendal_stat_options_set_override_content_type(struct opendal_stat_options *opts,
                                                    const char *override_content_type);
 
void opendal_stat_options_set_override_cache_control(struct opendal_stat_options *opts,
                                                     const char *override_cache_control);
 
void opendal_stat_options_set_override_content_disposition(struct opendal_stat_options *opts,
                                                           const char *override_content_disposition);
 
struct opendal_read_options *opendal_read_options_new(void);
 
void opendal_read_options_free(struct opendal_read_options *opts);
 
void opendal_read_options_set_range(struct opendal_read_options *opts,
                                    uint64_t offset,
                                    uint64_t length);
 
void opendal_read_options_set_range_from(struct opendal_read_options *opts, uint64_t offset);
 
void opendal_read_options_set_version(struct opendal_read_options *opts, const char *version);
 
void opendal_read_options_set_if_match(struct opendal_read_options *opts, const char *if_match);
 
void opendal_read_options_set_if_none_match(struct opendal_read_options *opts,
                                            const char *if_none_match);
 
void opendal_read_options_set_if_modified_since(struct opendal_read_options *opts,
                                                int64_t if_modified_since);
 
void opendal_read_options_set_if_unmodified_since(struct opendal_read_options *opts,
                                                  int64_t if_unmodified_since);
 
void opendal_read_options_set_concurrent(struct opendal_read_options *opts, uintptr_t concurrent);
 
void opendal_read_options_set_chunk(struct opendal_read_options *opts, uintptr_t chunk);
 
void opendal_read_options_set_gap(struct opendal_read_options *opts, uintptr_t gap);
 
void opendal_read_options_set_content_length_hint(struct opendal_read_options *opts,
                                                  uint64_t content_length_hint);
 
void opendal_read_options_set_override_content_type(struct opendal_read_options *opts,
                                                    const char *override_content_type);
 
void opendal_read_options_set_override_cache_control(struct opendal_read_options *opts,
                                                     const char *override_cache_control);
 
void opendal_read_options_set_override_content_disposition(struct opendal_read_options *opts,
                                                           const char *override_content_disposition);
 
struct opendal_reader_options *opendal_reader_options_new(void);
 
void opendal_reader_options_free(struct opendal_reader_options *opts);
 
void opendal_reader_options_set_version(struct opendal_reader_options *opts, const char *version);
 
void opendal_reader_options_set_if_match(struct opendal_reader_options *opts, const char *if_match);
 
void opendal_reader_options_set_if_none_match(struct opendal_reader_options *opts,
                                              const char *if_none_match);
 
void opendal_reader_options_set_if_modified_since(struct opendal_reader_options *opts,
                                                  int64_t if_modified_since);
 
void opendal_reader_options_set_if_unmodified_since(struct opendal_reader_options *opts,
                                                    int64_t if_unmodified_since);
 
void opendal_reader_options_set_content_length_hint(struct opendal_reader_options *opts,
                                                    uint64_t content_length_hint);
 
void opendal_reader_options_set_concurrent(struct opendal_reader_options *opts,
                                           uintptr_t concurrent);
 
void opendal_reader_options_set_chunk(struct opendal_reader_options *opts, uintptr_t chunk);
 
void opendal_reader_options_set_gap(struct opendal_reader_options *opts, uintptr_t gap);
 
void opendal_reader_options_set_prefetch(struct opendal_reader_options *opts, uintptr_t prefetch);
 
struct opendal_copy_options *opendal_copy_options_new(void);
 
void opendal_copy_options_free(struct opendal_copy_options *opts);
 
void opendal_copy_options_set_if_not_exists(struct opendal_copy_options *opts, bool if_not_exists);
 
void opendal_copy_options_set_if_match(struct opendal_copy_options *opts, const char *if_match);
 
void opendal_copy_options_set_source_version(struct opendal_copy_options *opts,
                                             const char *source_version);
 
void opendal_copy_options_set_source_content_length_hint(struct opendal_copy_options *opts,
                                                         uint64_t source_content_length_hint);
 
void opendal_copy_options_set_concurrent(struct opendal_copy_options *opts, uintptr_t concurrent);
 
void opendal_copy_options_set_chunk(struct opendal_copy_options *opts, uintptr_t chunk);
 
struct opendal_operator_options *opendal_operator_options_new(void);
 
void opendal_operator_options_set(struct opendal_operator_options *self,
                                  const char *key,
                                  const char *value);
 
void opendal_operator_options_free(struct opendal_operator_options *ptr);
 
char *opendal_entry_path(const struct opendal_entry *self);
 
char *opendal_entry_name(const struct opendal_entry *self);
 
struct opendal_metadata *opendal_entry_metadata(const struct opendal_entry *self);
 
void opendal_entry_free(struct opendal_entry *ptr);
 
struct opendal_result_reader_read opendal_reader_read(struct opendal_reader *self,
                                                      uint8_t *buf,
                                                      uintptr_t len);
 
struct opendal_result_reader_seek opendal_reader_seek(struct opendal_reader *self,
                                                      int64_t offset,
                                                      int32_t whence);
 
void opendal_reader_free(struct opendal_reader *ptr);
 
struct opendal_result_writer_write opendal_writer_write(struct opendal_writer *self,
                                                        const struct opendal_bytes *bytes);
 
struct opendal_error *opendal_writer_close(struct opendal_writer *ptr);
 
struct opendal_result_write opendal_writer_close_with_metadata(struct opendal_writer *ptr);
 
void opendal_writer_free(struct opendal_writer *ptr);
 
struct opendal_result_copier_next opendal_copier_next(struct opendal_copier *self);
 
struct opendal_error *opendal_copier_abort(struct opendal_copier *self);
 
void opendal_copier_free(struct opendal_copier *ptr);
 
#ifdef __cplusplus
}  // extern "C"
#endif  // __cplusplus
 
#endif  /* _OPENDAL_H */