mmkv 0.8.1

Rust version of MMKV
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>

enum Types {
  I32,
  Str,
  Bool,
  I64,
  F32,
  F64,
  ByteArray,
  I32Array,
  I64Array,
  F32Array,
  F64Array,
};

struct ByteSlice {
  const uint8_t *bytes;
  uintptr_t len;
};

struct NativeLogger {
  void *obj;
  void (*callback)(void *obj, int32_t level, const struct ByteSlice *content);
  void (*destroy)(void *obj);
};

struct InternalError {
  int32_t code;
  const struct ByteSlice *reason;
};

struct RawBuffer {
  const void *raw_data;
  enum Types type_token;
  const struct InternalError *err;
};

typedef const char *RawCStr;

typedef const uint8_t *CByteArray;

typedef const int32_t *CI32Array;

typedef const int64_t *CI64Array;

typedef const float *CF32Array;

typedef const double *CF64Array;

struct RawTypedArray {
  const void *array;
  enum Types type_token;
  uintptr_t len;
};

const void *new_instance(const char *dir);

void set_logger(struct NativeLogger logger);

void set_log_level(int32_t log_level);

void free_buffer(const void *ptr);

void close_instance(const void *ptr);

void clear_data(const void *ptr);

const struct RawBuffer *delete(const void *ptr, RawCStr key);

const struct RawBuffer *put_str(const void *ptr, RawCStr key, RawCStr value);

const struct RawBuffer *put_bool(const void *ptr, RawCStr key, bool value);

const struct RawBuffer *put_i32(const void *ptr, RawCStr key, int32_t value);

const struct RawBuffer *put_i64(const void *ptr, RawCStr key, int64_t value);

const struct RawBuffer *put_f32(const void *ptr, RawCStr key, float value);

const struct RawBuffer *put_f64(const void *ptr, RawCStr key, double value);

const struct RawBuffer *get_str(const void *ptr, RawCStr key);

const struct RawBuffer *get_bool(const void *ptr, RawCStr key);

const struct RawBuffer *get_i32(const void *ptr, RawCStr key);

const struct RawBuffer *get_i64(const void *ptr, RawCStr key);

const struct RawBuffer *get_f32(const void *ptr, RawCStr key);

const struct RawBuffer *get_f64(const void *ptr, RawCStr key);

const struct RawBuffer *get_byte_array(const void *ptr, RawCStr key);

const struct RawBuffer *get_i32_array(const void *ptr, RawCStr key);

const struct RawBuffer *get_i64_array(const void *ptr, RawCStr key);

const struct RawBuffer *get_f32_array(const void *ptr, RawCStr key);

const struct RawBuffer *get_f64_array(const void *ptr, RawCStr key);

const struct RawBuffer *put_byte_array(const void *ptr,
                                       RawCStr key,
                                       CByteArray value,
                                       uintptr_t len);

const struct RawBuffer *put_i32_array(const void *ptr, RawCStr key, CI32Array value, uintptr_t len);

const struct RawBuffer *put_i64_array(const void *ptr, RawCStr key, CI64Array value, uintptr_t len);

const struct RawBuffer *put_f32_array(const void *ptr, RawCStr key, CF32Array value, uintptr_t len);

const struct RawBuffer *put_f64_array(const void *ptr, RawCStr key, CF64Array value, uintptr_t len);