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_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_metadata {
  void *inner;
} opendal_metadata;
 
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_result_read {
  struct opendal_bytes data;
  struct opendal_error *error;
} opendal_result_read;
 
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_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_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_result_list {
  struct opendal_lister *lister;
  struct opendal_error *error;
} opendal_result_list;
 
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 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 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_cache_control;
  uintptr_t write_multi_max_size;
  uintptr_t write_multi_min_size;
  uintptr_t write_total_max_size;
  bool create_dir;
  bool delete_;
  bool copy;
  bool rename;
  bool list;
  bool list_with_limit;
  bool list_with_start_after;
  bool list_with_recursive;
  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;
 
#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);
 
void opendal_metadata_free(struct opendal_metadata *ptr);
 
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);
 
int64_t opendal_metadata_last_modified_ms(const struct opendal_metadata *self);
 
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_error *opendal_operator_write(const struct opendal_operator *op,
                                             const char *path,
                                             const struct opendal_bytes *bytes);
 
struct opendal_result_read opendal_operator_read(const struct opendal_operator *op,
                                                 const char *path);
 
struct opendal_result_operator_reader opendal_operator_reader(const struct opendal_operator *op,
                                                              const char *path);
 
struct opendal_result_operator_writer opendal_operator_writer(const struct opendal_operator *op,
                                                              const char *path);
 
struct opendal_error *opendal_operator_delete(const struct opendal_operator *op, const char *path);
 
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_list opendal_operator_list(const struct opendal_operator *op,
                                                 const char *path);
 
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_check(const struct opendal_operator *op);
 
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_full_capability(const struct opendal_operator_info *self);
 
struct opendal_capability opendal_operator_info_get_native_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_write(const struct opendal_operator *op,
                                                             const char *path,
                                                             uint64_t expire_secs);
 
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_stat(const struct opendal_operator *op,
                                                            const char *path,
                                                            uint64_t expire_secs);
 
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_bytes_free(struct opendal_bytes *ptr);
 
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);
 
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);
 
void opendal_writer_free(struct opendal_writer *ptr);
 
#ifdef __cplusplus
}  // extern "C"
#endif  // __cplusplus
 
#endif  /* _OPENDAL_H */