interop/interop library

Classes

leveldb_cache_t

leveldb_comparator_t

leveldb_env_t

leveldb_filterpolicy_t

leveldb_iterator_t

leveldb_logger_t

leveldb_options_t

typedef struct leveldb_options_t leveldb_options_t;

leveldb_readoptions_t

typedef struct leveldb_readoptions_t leveldb_readoptions_t;

leveldb_snapshot_t

typedef struct leveldb_snapshot_t leveldb_snapshot_t;

leveldb_t

typedef struct leveldb_t leveldb_t;

leveldb_writebatch_t

leveldb_writeoptions_t

typedef struct leveldb_writeoptions_t leveldb_writeoptions_t;

LibLevelDB

Constants

leveldb_no_compression → const int

enum { leveldb_no_compression = 0, leveldb_snappy_compression = 1 };

leveldb_snappy_compression → const int

Typedefs

Comparator_compare = int Function(Pointer<Void>, Pointer<Utf8> a, int alen, Pointer<Utf8> b, int blen)

int (*compare)(void*, const char* a, size_t alen, const char* b, size_t blen)

comparator_compare = IntPtr Function(Pointer<Void>, Pointer<Utf8> a, IntPtr alen, Pointer<Utf8> b, IntPtr blen)

Comparator_destructor = void Function(Pointer<Void>)

void (*destructor)(void*)

comparator_destructor = Void Function(Pointer<Void>)

Comparator_name = Pointer<Utf8> Function(Pointer<Void>)

const char* (*name)(void*)

comparator_name = Pointer<Utf8> Function(Pointer<Void>)

Filterpolicy_create_filter = Pointer<Uint8> Function(Pointer<Void>, Pointer<Pointer<Uint8>> key_array, Pointer<IntPtr> key_length_array, int num_keys, Pointer<IntPtr> filter_length)

char* (*create_filter)(void*, const char* const* key_array, const size_t* key_length_array, int num_keys, size_t* filter_length)

filterpolicy_create_filter = Pointer<Uint8> Function(Pointer<Void>, Pointer<Pointer<Uint8>> key_array, Pointer<IntPtr> key_length_array, IntPtr num_keys, Pointer<IntPtr> filter_length)

Filterpolicy_destructor = void Function(Pointer<Void>)

void (*destructor)(void*)

filterpolicy_destructor = Void Function(Pointer<Void>)

Filterpolicy_key_may_match = int Function(Pointer<Void>, Pointer<Uint8> key, int length, Pointer<Uint8> filter, int filter_length)

uint8_t (*key_may_match)(void*, const char* key, size_t length, const char* filter, size_t filter_length)

filterpolicy_key_may_match = Uint8 Function(Pointer<Void>, Pointer<Uint8> key, IntPtr length, Pointer<Uint8> filter, IntPtr filter_length)

Filterpolicy_name = Pointer<Utf8> Function(Pointer<Void>)

const char* (*name)(void*)

filterpolicy_name = Pointer<Utf8> Function(Pointer<Void>)

leveldb_approximate_sizes = Void Function(Pointer<leveldb_t> db, IntPtr num_ranges, Pointer<Pointer<Uint8>> range_start_key, Pointer<IntPtr> range_start_key_len, Pointer<Pointer<Uint8>> range_limit_key, Pointer<IntPtr> range_limit_key_len, Pointer<Uint64> sizes)

Leveldb_approximate_sizes = void Function(Pointer<leveldb_t> db, int num_ranges, Pointer<Pointer<Uint8>> range_start_key, Pointer<IntPtr> range_start_key_len, Pointer<Pointer<Uint8>> range_limit_key, Pointer<IntPtr> range_limit_key_len, Pointer<Uint64> sizes)

LEVELDB_EXPORT void leveldb_approximate_sizes( leveldb_t* db, int num_ranges, const char* const* range_start_key, const size_t* range_start_key_len, const char* const* range_limit_key, const size_t* range_limit_key_len, uint64_t* sizes);

leveldb_cache_create_lru = Pointer<leveldb_cache_t> Function(IntPtr)

Leveldb_cache_create_lru = Pointer<leveldb_cache_t> Function(int)

LEVELDB_EXPORT leveldb_cache_t* leveldb_cache_create_lru(size_t capacity);

Leveldb_cache_destroy = void Function(Pointer<leveldb_cache_t>)

LEVELDB_EXPORT void leveldb_cache_destroy(leveldb_cache_t* cache);

leveldb_cache_destroy = Void Function(Pointer<leveldb_cache_t>)

Leveldb_close = void Function(Pointer<leveldb_t> db)

LEVELDB_EXPORT void leveldb_close(leveldb_t* db);

leveldb_close = Void Function(Pointer<leveldb_t> db)

Leveldb_compact_range = void Function(Pointer<leveldb_t> db, Pointer<Uint8> start_key, int start_key_len, Pointer<Uint8> limit_key, int limit_key_len)

LEVELDB_EXPORT void leveldb_compact_range(leveldb_t* db, const char* start_key, size_t start_key_len, const char* limit_key, size_t limit_key_len);

leveldb_compact_range = Void Function(Pointer<leveldb_t> db, Pointer<Uint8> start_key, IntPtr start_key_len, Pointer<Uint8> limit_key, IntPtr limit_key_len)

Leveldb_comparator_create = Pointer<leveldb_comparator_t> Function(Pointer<NativeFunction<comparator_destructor>> destructor, Pointer<NativeFunction<comparator_compare>> compare, Pointer<NativeFunction<comparator_name>> name)

LEVELDB_EXPORT leveldb_comparator_t* leveldb_comparator_create( void* state, void (*destructor)(void*), int (*compare)(void*, const char* a, size_t alen, const char* b, size_t blen), const char* (*name)(void*));

leveldb_comparator_create = Pointer<leveldb_comparator_t> Function(Pointer<NativeFunction<comparator_destructor>> destructor, Pointer<NativeFunction<comparator_compare>> compare, Pointer<NativeFunction<comparator_name>> name)

Leveldb_comparator_destroy = void Function(Pointer<leveldb_comparator_t>)

LEVELDB_EXPORT void leveldb_comparator_destroy(leveldb_comparator_t*);

leveldb_comparator_destroy = Void Function(Pointer<leveldb_comparator_t>)

Leveldb_create_default_env = Pointer<leveldb_env_t> Function()

LEVELDB_EXPORT leveldb_env_t* leveldb_create_default_env(void);

leveldb_create_default_env = Pointer<leveldb_env_t> Function()

Leveldb_create_iterator = Pointer<leveldb_iterator_t> Function(Pointer<leveldb_t> db, Pointer<leveldb_readoptions_t> options)

LEVELDB_EXPORT leveldb_iterator_t* leveldb_create_iterator( leveldb_t* db, const leveldb_readoptions_t* options);

leveldb_create_iterator = Pointer<leveldb_iterator_t> Function(Pointer<leveldb_t> db, Pointer<leveldb_readoptions_t> options)

leveldb_create_snapshot = Pointer<leveldb_snapshot_t> Function(Pointer<leveldb_t> db)

Leveldb_create_snapshot = Pointer<leveldb_snapshot_t> Function(Pointer<leveldb_t> db)

LEVELDB_EXPORT const leveldb_snapshot_t* leveldb_create_snapshot(leveldb_t* db);

Leveldb_delete = void Function(Pointer<leveldb_t> db, Pointer<leveldb_writeoptions_t> options, Pointer<Uint8> key, int keylen, Pointer<Pointer<Utf8>> errptr)

LEVELDB_EXPORT void leveldb_delete(leveldb_t* db, const leveldb_writeoptions_t* options, const char* key, size_t keylen, char** errptr);

leveldb_delete = Void Function(Pointer<leveldb_t> db, Pointer<leveldb_writeoptions_t> options, Pointer<Uint8> key, IntPtr keylen, Pointer<Pointer<Utf8>> errptr)

Leveldb_destroy_db = void Function(Pointer<leveldb_options_t> options, Pointer<Utf8> name, Pointer<Pointer<Utf8>> errptr)

LEVELDB_EXPORT void leveldb_destroy_db(const leveldb_options_t* options, const char* name, char** errptr);

leveldb_destroy_db = Void Function(Pointer<leveldb_options_t> options, Pointer<Utf8> name, Pointer<Pointer<Utf8>> errptr)

Leveldb_env_destroy = void Function(Pointer<leveldb_env_t>)

LEVELDB_EXPORT void leveldb_env_destroy(leveldb_env_t*);

leveldb_env_destroy = Void Function(Pointer<leveldb_env_t>)

leveldb_filterpolicy_create = Pointer<leveldb_filterpolicy_t> Function(Pointer<NativeFunction<filterpolicy_destructor>> destructor, Pointer<NativeFunction<filterpolicy_create_filter>> create_filter, Pointer<NativeFunction<filterpolicy_key_may_match>> key_may_match, Pointer<NativeFunction<filterpolicy_name>> name)

Leveldb_filterpolicy_create = Pointer<leveldb_filterpolicy_t> Function(Pointer<NativeFunction<filterpolicy_destructor>> destructor, Pointer<NativeFunction<filterpolicy_create_filter>> create_filter, Pointer<NativeFunction<filterpolicy_key_may_match>> key_may_match, Pointer<NativeFunction<filterpolicy_name>> name)

LEVELDB_EXPORT leveldb_filterpolicy_t* leveldb_filterpolicy_create( void* state, void (*destructor)(void*), char* (*create_filter)(void*, const char* const* key_array, const size_t* key_length_array, int num_keys, size_t* filter_length), uint8_t (*key_may_match)(void*, const char* key, size_t length, const char* filter, size_t filter_length), const char* (*name)(void*));

leveldb_filterpolicy_create_bloom = Pointer<leveldb_filterpolicy_t> Function(IntPtr bits_per_key)

Leveldb_filterpolicy_create_bloom = Pointer<leveldb_filterpolicy_t> Function(int bits_per_key)

LEVELDB_EXPORT leveldb_filterpolicy_t* leveldb_filterpolicy_create_bloom( int bits_per_key);

leveldb_filterpolicy_destroy = Void Function(Pointer<leveldb_filterpolicy_t>)

Leveldb_filterpolicy_destroy = void Function(Pointer<leveldb_filterpolicy_t>)

LEVELDB_EXPORT void leveldb_filterpolicy_destroy(leveldb_filterpolicy_t*);

leveldb_free = Void Function(Pointer<Void> options)

Leveldb_free = void Function(Pointer<Void> options)

/* Calls free(ptr). REQUIRES: ptr was malloc()-ed and returned by one of the routines in this file. Note that in certain cases (typically on Windows), you may need to call this routine instead of free(ptr) to dispose of malloc()-ed memory returned by this library. */ LEVELDB_EXPORT void leveldb_free(void* ptr);

leveldb_get = Pointer<Uint8> Function(Pointer<leveldb_t> db, Pointer<leveldb_readoptions_t> options, Pointer<Uint8> key, IntPtr keylen, Pointer<IntPtr> vallen, Pointer<Pointer<Utf8>> errptr)

Leveldb_get = Pointer<Uint8> Function(Pointer<leveldb_t> db, Pointer<leveldb_readoptions_t> options, Pointer<Uint8> key, int keylen, Pointer<IntPtr> vallen, Pointer<Pointer<Utf8>> errptr)

Returns NULL if not found. A malloc()ed array otherwise. Stores the length of the array in *vallen.

leveldb_iter_destroy = Void Function(Pointer<leveldb_iterator_t>)

Leveldb_iter_destroy = void Function(Pointer<leveldb_iterator_t>)

LEVELDB_EXPORT void leveldb_iter_destroy(leveldb_iterator_t*);

leveldb_iter_get_error = Void Function(Pointer<leveldb_iterator_t>, Pointer<Pointer<Utf8>> errptr)

Leveldb_iter_get_error = void Function(Pointer<leveldb_iterator_t>, Pointer<Pointer<Utf8>> errptr)

LEVELDB_EXPORT void leveldb_iter_get_error(const leveldb_iterator_t*, char** errptr);

leveldb_iter_key = Pointer<Uint8> Function(Pointer<leveldb_iterator_t>, Pointer<IntPtr> klen)

Leveldb_iter_key = Pointer<Uint8> Function(Pointer<leveldb_iterator_t>, Pointer<IntPtr> klen)

LEVELDB_EXPORT const char* leveldb_iter_key(const leveldb_iterator_t*, size_t* klen);

Leveldb_iter_next = void Function(Pointer<leveldb_iterator_t>)

LEVELDB_EXPORT void leveldb_iter_next(leveldb_iterator_t*);

leveldb_iter_next = Void Function(Pointer<leveldb_iterator_t>)

leveldb_iter_prev = Void Function(Pointer<leveldb_iterator_t>)

Leveldb_iter_prev = void Function(Pointer<leveldb_iterator_t>)

LEVELDB_EXPORT void leveldb_iter_prev(leveldb_iterator_t*);

Leveldb_iter_seek = Pointer<Uint8> Function(Pointer<leveldb_iterator_t>, Pointer<Uint8> k, int klen)

LEVELDB_EXPORT Pointer<Utf8> leveldb_iter_seek(leveldb_iterator_t*, const char* k, size_t klen);

leveldb_iter_seek = Pointer<Uint8> Function(Pointer<leveldb_iterator_t>, Pointer<Uint8> k, IntPtr klen)

Leveldb_iter_seek_to_first = void Function(Pointer<leveldb_iterator_t>)

LEVELDB_EXPORT void leveldb_iter_seek_to_first(leveldb_iterator_t*);

leveldb_iter_seek_to_first = Void Function(Pointer<leveldb_iterator_t>)

Leveldb_iter_seek_to_last = void Function(Pointer<leveldb_iterator_t>)

LEVELDB_EXPORT void leveldb_iter_seek_to_last(leveldb_iterator_t*);

leveldb_iter_seek_to_last = Void Function(Pointer<leveldb_iterator_t>)

leveldb_iter_valid = Uint8 Function(Pointer<leveldb_iterator_t>)

Leveldb_iter_valid = int Function(Pointer<leveldb_iterator_t>)

LEVELDB_EXPORT uint8_t leveldb_iter_valid(const leveldb_iterator_t*);

leveldb_iter_value = Pointer<Uint8> Function(Pointer<leveldb_iterator_t>, Pointer<IntPtr> vlen)

Leveldb_iter_value = Pointer<Uint8> Function(Pointer<leveldb_iterator_t>, Pointer<IntPtr> vlen)

LEVELDB_EXPORT const char* leveldb_iter_value(const leveldb_iterator_t*, size_t* vlen);

leveldb_major_version = IntPtr Function()

Leveldb_major_version = int Function()

/* Return the major version number for this release. */ LEVELDB_EXPORT int leveldb_major_version(void);

leveldb_minor_version = IntPtr Function()

Leveldb_minor_version = int Function()

/* Return the minor version number for this release. */ LEVELDB_EXPORT int leveldb_minor_version(void);

leveldb_open = Pointer<leveldb_t> Function(Pointer<leveldb_options_t> options, Pointer<Utf8> name, Pointer<Pointer<Utf8>> errptr)

Leveldb_open = Pointer<leveldb_t> Function(Pointer<leveldb_options_t> options, Pointer<Utf8> name, Pointer<Pointer<Utf8>> errptr)

LEVELDB_EXPORT leveldb_t* leveldb_open(const leveldb_options_t* options, const char* name, char** errptr);

leveldb_options_create = Pointer<leveldb_options_t> Function()

Leveldb_options_create = Pointer<leveldb_options_t> Function()

LEVELDB_EXPORT leveldb_options_t* leveldb_options_create(void);

Leveldb_options_destroy = void Function(Pointer<leveldb_options_t>)

LEVELDB_EXPORT void leveldb_options_destroy(leveldb_options_t*);

leveldb_options_destroy = Void Function(Pointer<leveldb_options_t>)

Leveldb_options_set_block_restart_interval = void Function(Pointer<leveldb_options_t>, int)

LEVELDB_EXPORT void leveldb_options_set_block_restart_interval( leveldb_options_t*, int);

leveldb_options_set_block_restart_interval = Void Function(Pointer<leveldb_options_t>, Int32)

Leveldb_options_set_block_size = void Function(Pointer<leveldb_options_t>, int)

LEVELDB_EXPORT void leveldb_options_set_block_size(leveldb_options_t*, size_t);

leveldb_options_set_block_size = Void Function(Pointer<leveldb_options_t>, IntPtr)

Leveldb_options_set_cache = void Function(Pointer<leveldb_options_t>, Pointer<leveldb_cache_t>)

LEVELDB_EXPORT void leveldb_options_set_cache(leveldb_options_t*, leveldb_cache_t*);

leveldb_options_set_cache = Void Function(Pointer<leveldb_options_t>, Pointer<leveldb_cache_t>)

Leveldb_options_set_comparator = void Function(Pointer<leveldb_options_t>, Pointer<leveldb_comparator_t>)

LEVELDB_EXPORT void leveldb_options_set_comparator(leveldb_options_t*, leveldb_comparator_t*);

leveldb_options_set_comparator = Void Function(Pointer<leveldb_options_t>, Pointer<leveldb_comparator_t>)

Leveldb_options_set_compression = void Function(Pointer<leveldb_options_t>, int)

LEVELDB_EXPORT void leveldb_options_set_compression(leveldb_options_t*, int);

leveldb_options_set_compression = Void Function(Pointer<leveldb_options_t>, Uint32)

Leveldb_options_set_create_if_missing = void Function(Pointer<leveldb_options_t>, int)

LEVELDB_EXPORT void leveldb_options_set_create_if_missing(leveldb_options_t*, uint8_t);

leveldb_options_set_create_if_missing = Void Function(Pointer<leveldb_options_t>, Uint8)

leveldb_options_set_env = Void Function(Pointer<leveldb_options_t>, Pointer<leveldb_env_t>)

Leveldb_options_set_env = void Function(Pointer<leveldb_options_t>, Pointer<leveldb_env_t>)

LEVELDB_EXPORT void leveldb_options_set_env(leveldb_options_t*, leveldb_env_t*);

leveldb_options_set_error_if_exists = Void Function(Pointer<leveldb_options_t>, Uint8)

Leveldb_options_set_error_if_exists = void Function(Pointer<leveldb_options_t>, int)

LEVELDB_EXPORT void leveldb_options_set_error_if_exists(leveldb_options_t*, uint8_t);

leveldb_options_set_filter_policy = Void Function(Pointer<leveldb_options_t>, Pointer<leveldb_filterpolicy_t>)

Leveldb_options_set_filter_policy = void Function(Pointer<leveldb_options_t>, Pointer<leveldb_filterpolicy_t>)

LEVELDB_EXPORT void leveldb_options_set_filter_policy(leveldb_options_t*, leveldb_filterpolicy_t*);

Leveldb_options_set_info_log = void Function(Pointer<leveldb_options_t>, Pointer<leveldb_logger_t>)

LEVELDB_EXPORT void leveldb_options_set_info_log(leveldb_options_t*, leveldb_logger_t*);

leveldb_options_set_info_log = Void Function(Pointer<leveldb_options_t>, Pointer<leveldb_logger_t>)

Leveldb_options_set_max_file_size = void Function(Pointer<leveldb_options_t>, int)

LEVELDB_EXPORT void leveldb_options_set_max_file_size(leveldb_options_t*, size_t);

leveldb_options_set_max_file_size = Void Function(Pointer<leveldb_options_t>, IntPtr)

leveldb_options_set_max_open_files = Void Function(Pointer<leveldb_options_t>, Int32)

Leveldb_options_set_max_open_files = void Function(Pointer<leveldb_options_t>, int)

LEVELDB_EXPORT void leveldb_options_set_max_open_files(leveldb_options_t*, int);

Leveldb_options_set_paranoid_checks = void Function(Pointer<leveldb_options_t>, int)

LEVELDB_EXPORT void leveldb_options_set_paranoid_checks(leveldb_options_t*, uint8_t);

leveldb_options_set_paranoid_checks = Void Function(Pointer<leveldb_options_t>, Uint8)

leveldb_options_set_write_buffer_size = Void Function(Pointer<leveldb_options_t>, IntPtr)

Leveldb_options_set_write_buffer_size = void Function(Pointer<leveldb_options_t>, int)

LEVELDB_EXPORT void leveldb_options_set_write_buffer_size(leveldb_options_t*, size_t);

Leveldb_property_value = Pointer<Utf8> Function(Pointer<leveldb_t> db, Pointer<Utf8> propname)

Returns Null-terminated string

leveldb_property_value = Pointer<Utf8> Function(Pointer<leveldb_t> db, Pointer<Utf8> propname)

leveldb_put = Void Function(Pointer<leveldb_t> db, Pointer<leveldb_writeoptions_t> options, Pointer<Uint8> key, IntPtr keylen, Pointer<Uint8> val, IntPtr vallen, Pointer<Pointer<Utf8>> errptr)

Leveldb_put = void Function(Pointer<leveldb_t> db, Pointer<leveldb_writeoptions_t> options, Pointer<Uint8> key, int keylen, Pointer<Uint8> val, int vallen, Pointer<Pointer<Utf8>> errptr)

LEVELDB_EXPORT void leveldb_put(leveldb_t* db, const leveldb_writeoptions_t* options, const char* key, size_t keylen, const char* val, size_t vallen, char** errptr);

leveldb_readoptions_create = Pointer<leveldb_readoptions_t> Function()

Leveldb_readoptions_create = Pointer<leveldb_readoptions_t> Function()

LEVELDB_EXPORT leveldb_readoptions_t* leveldb_readoptions_create(void);

leveldb_readoptions_destroy = Void Function(Pointer<leveldb_readoptions_t>)

Leveldb_readoptions_destroy = void Function(Pointer<leveldb_readoptions_t>)

LEVELDB_EXPORT void leveldb_readoptions_destroy(leveldb_readoptions_t*);

Leveldb_readoptions_set_fill_cache = void Function(Pointer<leveldb_readoptions_t>, int)

LEVELDB_EXPORT void leveldb_readoptions_set_fill_cache(leveldb_readoptions_t*, uint8_t);

leveldb_readoptions_set_fill_cache = Void Function(Pointer<leveldb_readoptions_t>, Uint8)

Leveldb_readoptions_set_snapshot = void Function(Pointer<leveldb_readoptions_t>, Pointer<leveldb_snapshot_t>)

LEVELDB_EXPORT void leveldb_readoptions_set_snapshot(leveldb_readoptions_t*, const leveldb_snapshot_t*);

leveldb_readoptions_set_snapshot = Void Function(Pointer<leveldb_readoptions_t>, Pointer<leveldb_snapshot_t>)

leveldb_readoptions_set_verify_checksums = Void Function(Pointer<leveldb_readoptions_t>, Uint8)

Leveldb_readoptions_set_verify_checksums = void Function(Pointer<leveldb_readoptions_t>, int)

LEVELDB_EXPORT void leveldb_readoptions_set_verify_checksums( leveldb_readoptions_t*, uint8_t);

leveldb_release_snapshot = Void Function(Pointer<leveldb_t> db, Pointer<leveldb_snapshot_t> snapshot)

Leveldb_release_snapshot = void Function(Pointer<leveldb_t> db, Pointer<leveldb_snapshot_t> snapshot)

LEVELDB_EXPORT void leveldb_release_snapshot( leveldb_t* db, const leveldb_snapshot_t* snapshot);

Leveldb_repair_db = void Function(Pointer<leveldb_options_t> options, Pointer<Utf8> name, Pointer<Pointer<Utf8>> errptr)

LEVELDB_EXPORT void leveldb_repair_db(const leveldb_options_t* options, const char* name, char** errptr);

leveldb_repair_db = Void Function(Pointer<leveldb_options_t> options, Pointer<Utf8> name, Pointer<Pointer<Utf8>> errptr)

Leveldb_write = void Function(Pointer<leveldb_t> db, Pointer<leveldb_writeoptions_t> options, Pointer<leveldb_writebatch_t> batch, Pointer<Pointer<Utf8>> errptr)

LEVELDB_EXPORT void leveldb_write(leveldb_t* db, const leveldb_writeoptions_t* options, leveldb_writebatch_t* batch, char** errptr);

leveldb_write = Void Function(Pointer<leveldb_t> db, Pointer<leveldb_writeoptions_t> options, Pointer<leveldb_writebatch_t> batch, Pointer<Pointer<Utf8>> errptr)

leveldb_writebatch_append = Void Function(Pointer<leveldb_writebatch_t> destination, Pointer<leveldb_writebatch_t> source)

Leveldb_writebatch_append = void Function(Pointer<leveldb_writebatch_t> destination, Pointer<leveldb_writebatch_t> source)

LEVELDB_EXPORT void leveldb_writebatch_append( leveldb_writebatch_t* destination, const leveldb_writebatch_t* source);

Leveldb_writebatch_clear = void Function(Pointer<leveldb_writebatch_t>)

LEVELDB_EXPORT void leveldb_writebatch_clear(leveldb_writebatch_t*);

leveldb_writebatch_clear = Void Function(Pointer<leveldb_writebatch_t>)

Leveldb_writebatch_create = Pointer<leveldb_writebatch_t> Function()

LEVELDB_EXPORT leveldb_writebatch_t* leveldb_writebatch_create(void);

leveldb_writebatch_create = Pointer<leveldb_writebatch_t> Function()

Leveldb_writebatch_delete = void Function(Pointer<leveldb_writebatch_t>, Pointer<Uint8> key, int klen)

LEVELDB_EXPORT void leveldb_writebatch_delete(leveldb_writebatch_t*, const char* key, size_t klen);

leveldb_writebatch_delete = Void Function(Pointer<leveldb_writebatch_t>, Pointer<Uint8> key, IntPtr klen)

Leveldb_writebatch_destroy = void Function(Pointer<leveldb_writebatch_t>)

LEVELDB_EXPORT void leveldb_writebatch_destroy(leveldb_writebatch_t*);

leveldb_writebatch_destroy = Void Function(Pointer<leveldb_writebatch_t>)

Leveldb_writebatch_iterate = void Function(Pointer<leveldb_writebatch_t>, Pointer<Void> state, Pointer<NativeFunction<writebatch_iterate_put>> put, Pointer<NativeFunction<writebatch_iterate_deleted>> deleted)

leveldb_writebatch_iterate = Void Function(Pointer<leveldb_writebatch_t>, Pointer<Void> state, Pointer<NativeFunction<writebatch_iterate_put>> put, Pointer<NativeFunction<writebatch_iterate_deleted>> deleted)

Leveldb_writebatch_put = void Function(Pointer<leveldb_writebatch_t>, Pointer<Uint8> key, int klen, Pointer<Uint8> val, int vlen)

LEVELDB_EXPORT void leveldb_writebatch_put(leveldb_writebatch_t*, const char* key, size_t klen, const char* val, size_t vlen);

leveldb_writebatch_put = Void Function(Pointer<leveldb_writebatch_t>, Pointer<Uint8> key, IntPtr klen, Pointer<Uint8> val, IntPtr vlen)

Leveldb_writeoptions_create = Pointer<leveldb_writeoptions_t> Function()

LEVELDB_EXPORT leveldb_writeoptions_t* leveldb_writeoptions_create(void);

leveldb_writeoptions_create = Pointer<leveldb_writeoptions_t> Function()

Leveldb_writeoptions_destroy = void Function(Pointer<leveldb_writeoptions_t>)

LEVELDB_EXPORT void leveldb_writeoptions_destroy(leveldb_writeoptions_t*);

leveldb_writeoptions_destroy = Void Function(Pointer<leveldb_writeoptions_t>)

leveldb_writeoptions_set_sync = Void Function(Pointer<leveldb_writeoptions_t>, Uint8)

Leveldb_writeoptions_set_sync = void Function(Pointer<leveldb_writeoptions_t>, int)

LEVELDB_EXPORT void leveldb_writeoptions_set_sync(leveldb_writeoptions_t*, uint8_t);

writebatch_iterate_deleted = Void Function(Pointer<Void>, Pointer<Uint8> k, IntPtr klen)

writebatch_iterate_put = Void Function(Pointer<Void>, Pointer<Uint8> k, IntPtr klen, Pointer<Uint8> v, IntPtr vlen)

LEVELDB_EXPORT void leveldb_writebatch_iterate( const leveldb_writebatch_t*, void* state, void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen), void (*deleted)(void*, const char* k, size_t klen));