Branch data Line data Source code
1 : : // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
2 : : // Use of this source code is governed by a BSD-style license that can be
3 : : // found in the LICENSE file. See the AUTHORS file for names of contributors.
4 : :
5 : : #include "leveldb/c.h"
6 : :
7 : : #include <cstdint>
8 : : #include <cstdlib>
9 : :
10 : : #include "leveldb/cache.h"
11 : : #include "leveldb/comparator.h"
12 : : #include "leveldb/db.h"
13 : : #include "leveldb/env.h"
14 : : #include "leveldb/filter_policy.h"
15 : : #include "leveldb/iterator.h"
16 : : #include "leveldb/options.h"
17 : : #include "leveldb/status.h"
18 : : #include "leveldb/write_batch.h"
19 : :
20 : : using leveldb::Cache;
21 : : using leveldb::Comparator;
22 : : using leveldb::CompressionType;
23 : : using leveldb::DB;
24 : : using leveldb::Env;
25 : : using leveldb::FileLock;
26 : : using leveldb::FilterPolicy;
27 : : using leveldb::Iterator;
28 : : using leveldb::kMajorVersion;
29 : : using leveldb::kMinorVersion;
30 : : using leveldb::Logger;
31 : : using leveldb::NewBloomFilterPolicy;
32 : : using leveldb::NewLRUCache;
33 : : using leveldb::Options;
34 : : using leveldb::RandomAccessFile;
35 : : using leveldb::Range;
36 : : using leveldb::ReadOptions;
37 : : using leveldb::SequentialFile;
38 : : using leveldb::Slice;
39 : : using leveldb::Snapshot;
40 : : using leveldb::Status;
41 : : using leveldb::WritableFile;
42 : : using leveldb::WriteBatch;
43 : : using leveldb::WriteOptions;
44 : :
45 : : extern "C" {
46 : :
47 : : struct leveldb_t {
48 : : DB* rep;
49 : : };
50 : : struct leveldb_iterator_t {
51 : : Iterator* rep;
52 : : };
53 : 0 : struct leveldb_writebatch_t {
54 : : WriteBatch rep;
55 : : };
56 : : struct leveldb_snapshot_t {
57 : : const Snapshot* rep;
58 : : };
59 : 0 : struct leveldb_readoptions_t {
60 : : ReadOptions rep;
61 : : };
62 : 0 : struct leveldb_writeoptions_t {
63 : : WriteOptions rep;
64 : : };
65 : 0 : struct leveldb_options_t {
66 : : Options rep;
67 : : };
68 : : struct leveldb_cache_t {
69 : : Cache* rep;
70 : : };
71 : : struct leveldb_seqfile_t {
72 : : SequentialFile* rep;
73 : : };
74 : : struct leveldb_randomfile_t {
75 : : RandomAccessFile* rep;
76 : : };
77 : : struct leveldb_writablefile_t {
78 : : WritableFile* rep;
79 : : };
80 : : struct leveldb_logger_t {
81 : : Logger* rep;
82 : : };
83 : : struct leveldb_filelock_t {
84 : : FileLock* rep;
85 : : };
86 : :
87 : 0 : struct leveldb_comparator_t : public Comparator {
88 : 0 : ~leveldb_comparator_t() override { (*destructor_)(state_); }
89 : :
90 : 0 : int Compare(const Slice& a, const Slice& b) const override {
91 : 0 : return (*compare_)(state_, a.data(), a.size(), b.data(), b.size());
92 : : }
93 : :
94 : 0 : const char* Name() const override { return (*name_)(state_); }
95 : :
96 : : // No-ops since the C binding does not support key shortening methods.
97 : 0 : void FindShortestSeparator(std::string*, const Slice&) const override {}
98 : 0 : void FindShortSuccessor(std::string* key) const override {}
99 : :
100 : : void* state_;
101 : : void (*destructor_)(void*);
102 : : int (*compare_)(void*, const char* a, size_t alen, const char* b,
103 : : size_t blen);
104 : : const char* (*name_)(void*);
105 : : };
106 : :
107 : 0 : struct leveldb_filterpolicy_t : public FilterPolicy {
108 : 0 : ~leveldb_filterpolicy_t() override { (*destructor_)(state_); }
109 : :
110 : 0 : const char* Name() const override { return (*name_)(state_); }
111 : :
112 : 0 : void CreateFilter(const Slice* keys, int n, std::string* dst) const override {
113 : 0 : std::vector<const char*> key_pointers(n);
114 [ # # ]: 0 : std::vector<size_t> key_sizes(n);
115 [ # # ]: 0 : for (int i = 0; i < n; i++) {
116 : 0 : key_pointers[i] = keys[i].data();
117 : 0 : key_sizes[i] = keys[i].size();
118 : : }
119 : 0 : size_t len;
120 [ # # ]: 0 : char* filter = (*create_)(state_, &key_pointers[0], &key_sizes[0], n, &len);
121 [ # # ]: 0 : dst->append(filter, len);
122 : 0 : free(filter);
123 : 0 : }
124 : :
125 : 0 : bool KeyMayMatch(const Slice& key, const Slice& filter) const override {
126 : 0 : return (*key_match_)(state_, key.data(), key.size(), filter.data(),
127 : 0 : filter.size());
128 : : }
129 : :
130 : : void* state_;
131 : : void (*destructor_)(void*);
132 : : const char* (*name_)(void*);
133 : : char* (*create_)(void*, const char* const* key_array,
134 : : const size_t* key_length_array, int num_keys,
135 : : size_t* filter_length);
136 : : uint8_t (*key_match_)(void*, const char* key, size_t length,
137 : : const char* filter, size_t filter_length);
138 : : };
139 : :
140 : : struct leveldb_env_t {
141 : : Env* rep;
142 : : bool is_default;
143 : : };
144 : :
145 : 0 : static bool SaveError(char** errptr, const Status& s) {
146 [ # # ]: 0 : assert(errptr != nullptr);
147 [ # # ]: 0 : if (s.ok()) {
148 : : return false;
149 [ # # ]: 0 : } else if (*errptr == nullptr) {
150 : 0 : *errptr = strdup(s.ToString().c_str());
151 : : } else {
152 : : // TODO(sanjay): Merge with existing error?
153 : 0 : free(*errptr);
154 : 0 : *errptr = strdup(s.ToString().c_str());
155 : : }
156 : : return true;
157 : : }
158 : :
159 : 0 : static char* CopyString(const std::string& str) {
160 [ # # ]: 0 : char* result = reinterpret_cast<char*>(malloc(sizeof(char) * str.size()));
161 : 0 : memcpy(result, str.data(), sizeof(char) * str.size());
162 : 0 : return result;
163 : : }
164 : :
165 : 0 : leveldb_t* leveldb_open(const leveldb_options_t* options, const char* name,
166 : : char** errptr) {
167 : 0 : DB* db;
168 [ # # # # : 0 : if (SaveError(errptr, DB::Open(options->rep, std::string(name), &db))) {
# # # # ]
169 : : return nullptr;
170 : : }
171 : 0 : leveldb_t* result = new leveldb_t;
172 : 0 : result->rep = db;
173 : 0 : return result;
174 : : }
175 : :
176 : 0 : void leveldb_close(leveldb_t* db) {
177 [ # # ]: 0 : delete db->rep;
178 [ # # ]: 0 : delete db;
179 : 0 : }
180 : :
181 : 0 : void leveldb_put(leveldb_t* db, const leveldb_writeoptions_t* options,
182 : : const char* key, size_t keylen, const char* val, size_t vallen,
183 : : char** errptr) {
184 [ # # ]: 0 : SaveError(errptr,
185 : 0 : db->rep->Put(options->rep, Slice(key, keylen), Slice(val, vallen)));
186 : 0 : }
187 : :
188 : 0 : void leveldb_delete(leveldb_t* db, const leveldb_writeoptions_t* options,
189 : : const char* key, size_t keylen, char** errptr) {
190 [ # # ]: 0 : SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen)));
191 : 0 : }
192 : :
193 : 0 : void leveldb_write(leveldb_t* db, const leveldb_writeoptions_t* options,
194 : : leveldb_writebatch_t* batch, char** errptr) {
195 [ # # ]: 0 : SaveError(errptr, db->rep->Write(options->rep, &batch->rep));
196 : 0 : }
197 : :
198 : 0 : char* leveldb_get(leveldb_t* db, const leveldb_readoptions_t* options,
199 : : const char* key, size_t keylen, size_t* vallen,
200 : : char** errptr) {
201 : 0 : char* result = nullptr;
202 [ # # ]: 0 : std::string tmp;
203 [ # # ]: 0 : Status s = db->rep->Get(options->rep, Slice(key, keylen), &tmp);
204 [ # # ]: 0 : if (s.ok()) {
205 [ # # ]: 0 : *vallen = tmp.size();
206 : 0 : result = CopyString(tmp);
207 : : } else {
208 : 0 : *vallen = 0;
209 [ # # # # ]: 0 : if (!s.IsNotFound()) {
210 [ # # ]: 0 : SaveError(errptr, s);
211 : : }
212 : : }
213 [ # # ]: 0 : return result;
214 : 0 : }
215 : :
216 : 0 : leveldb_iterator_t* leveldb_create_iterator(
217 : : leveldb_t* db, const leveldb_readoptions_t* options) {
218 : 0 : leveldb_iterator_t* result = new leveldb_iterator_t;
219 : 0 : result->rep = db->rep->NewIterator(options->rep);
220 : 0 : return result;
221 : : }
222 : :
223 : 0 : const leveldb_snapshot_t* leveldb_create_snapshot(leveldb_t* db) {
224 : 0 : leveldb_snapshot_t* result = new leveldb_snapshot_t;
225 : 0 : result->rep = db->rep->GetSnapshot();
226 : 0 : return result;
227 : : }
228 : :
229 : 0 : void leveldb_release_snapshot(leveldb_t* db,
230 : : const leveldb_snapshot_t* snapshot) {
231 : 0 : db->rep->ReleaseSnapshot(snapshot->rep);
232 [ # # ]: 0 : delete snapshot;
233 : 0 : }
234 : :
235 : 0 : char* leveldb_property_value(leveldb_t* db, const char* propname) {
236 [ # # ]: 0 : std::string tmp;
237 [ # # # # ]: 0 : if (db->rep->GetProperty(Slice(propname), &tmp)) {
238 : : // We use strdup() since we expect human readable output.
239 : 0 : return strdup(tmp.c_str());
240 : : } else {
241 : : return nullptr;
242 : : }
243 : 0 : }
244 : :
245 : 0 : void leveldb_approximate_sizes(leveldb_t* db, int num_ranges,
246 : : const char* const* range_start_key,
247 : : const size_t* range_start_key_len,
248 : : const char* const* range_limit_key,
249 : : const size_t* range_limit_key_len,
250 : : uint64_t* sizes) {
251 [ # # # # ]: 0 : Range* ranges = new Range[num_ranges];
252 [ # # ]: 0 : for (int i = 0; i < num_ranges; i++) {
253 : 0 : ranges[i].start = Slice(range_start_key[i], range_start_key_len[i]);
254 : 0 : ranges[i].limit = Slice(range_limit_key[i], range_limit_key_len[i]);
255 : : }
256 : 0 : db->rep->GetApproximateSizes(ranges, num_ranges, sizes);
257 [ # # ]: 0 : delete[] ranges;
258 : 0 : }
259 : :
260 : 0 : void leveldb_compact_range(leveldb_t* db, const char* start_key,
261 : : size_t start_key_len, const char* limit_key,
262 : : size_t limit_key_len) {
263 [ # # ]: 0 : Slice a, b;
264 [ # # # # ]: 0 : db->rep->CompactRange(
265 : : // Pass null Slice if corresponding "const char*" is null
266 : 0 : (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
267 : 0 : (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
268 : 0 : }
269 : :
270 : 0 : void leveldb_destroy_db(const leveldb_options_t* options, const char* name,
271 : : char** errptr) {
272 [ # # # # ]: 0 : SaveError(errptr, DestroyDB(name, options->rep));
273 : 0 : }
274 : :
275 : 0 : void leveldb_repair_db(const leveldb_options_t* options, const char* name,
276 : : char** errptr) {
277 [ # # # # ]: 0 : SaveError(errptr, RepairDB(name, options->rep));
278 : 0 : }
279 : :
280 : 0 : void leveldb_iter_destroy(leveldb_iterator_t* iter) {
281 [ # # ]: 0 : delete iter->rep;
282 [ # # ]: 0 : delete iter;
283 : 0 : }
284 : :
285 : 0 : uint8_t leveldb_iter_valid(const leveldb_iterator_t* iter) {
286 : 0 : return iter->rep->Valid();
287 : : }
288 : :
289 : 0 : void leveldb_iter_seek_to_first(leveldb_iterator_t* iter) {
290 : 0 : iter->rep->SeekToFirst();
291 : 0 : }
292 : :
293 : 0 : void leveldb_iter_seek_to_last(leveldb_iterator_t* iter) {
294 : 0 : iter->rep->SeekToLast();
295 : 0 : }
296 : :
297 : 0 : void leveldb_iter_seek(leveldb_iterator_t* iter, const char* k, size_t klen) {
298 : 0 : iter->rep->Seek(Slice(k, klen));
299 : 0 : }
300 : :
301 : 0 : void leveldb_iter_next(leveldb_iterator_t* iter) { iter->rep->Next(); }
302 : :
303 : 0 : void leveldb_iter_prev(leveldb_iterator_t* iter) { iter->rep->Prev(); }
304 : :
305 : 0 : const char* leveldb_iter_key(const leveldb_iterator_t* iter, size_t* klen) {
306 : 0 : Slice s = iter->rep->key();
307 : 0 : *klen = s.size();
308 : 0 : return s.data();
309 : : }
310 : :
311 : 0 : const char* leveldb_iter_value(const leveldb_iterator_t* iter, size_t* vlen) {
312 : 0 : Slice s = iter->rep->value();
313 : 0 : *vlen = s.size();
314 : 0 : return s.data();
315 : : }
316 : :
317 : 0 : void leveldb_iter_get_error(const leveldb_iterator_t* iter, char** errptr) {
318 [ # # ]: 0 : SaveError(errptr, iter->rep->status());
319 : 0 : }
320 : :
321 : 0 : leveldb_writebatch_t* leveldb_writebatch_create() {
322 [ # # ]: 0 : return new leveldb_writebatch_t;
323 : : }
324 : :
325 [ # # ]: 0 : void leveldb_writebatch_destroy(leveldb_writebatch_t* b) { delete b; }
326 : :
327 : 0 : void leveldb_writebatch_clear(leveldb_writebatch_t* b) { b->rep.Clear(); }
328 : :
329 : 0 : void leveldb_writebatch_put(leveldb_writebatch_t* b, const char* key,
330 : : size_t klen, const char* val, size_t vlen) {
331 : 0 : b->rep.Put(Slice(key, klen), Slice(val, vlen));
332 : 0 : }
333 : :
334 : 0 : void leveldb_writebatch_delete(leveldb_writebatch_t* b, const char* key,
335 : : size_t klen) {
336 : 0 : b->rep.Delete(Slice(key, klen));
337 : 0 : }
338 : :
339 : 0 : void leveldb_writebatch_iterate(const leveldb_writebatch_t* b, void* state,
340 : : void (*put)(void*, const char* k, size_t klen,
341 : : const char* v, size_t vlen),
342 : : void (*deleted)(void*, const char* k,
343 : : size_t klen)) {
344 : 0 : class H : public WriteBatch::Handler {
345 : : public:
346 : : void* state_;
347 : : void (*put_)(void*, const char* k, size_t klen, const char* v, size_t vlen);
348 : : void (*deleted_)(void*, const char* k, size_t klen);
349 : 0 : void Put(const Slice& key, const Slice& value) override {
350 : 0 : (*put_)(state_, key.data(), key.size(), value.data(), value.size());
351 : 0 : }
352 : 0 : void Delete(const Slice& key) override {
353 : 0 : (*deleted_)(state_, key.data(), key.size());
354 : 0 : }
355 : : };
356 [ # # ]: 0 : H handler;
357 : 0 : handler.state_ = state;
358 : 0 : handler.put_ = put;
359 : 0 : handler.deleted_ = deleted;
360 [ # # ]: 0 : b->rep.Iterate(&handler);
361 : 0 : }
362 : :
363 : 0 : void leveldb_writebatch_append(leveldb_writebatch_t* destination,
364 : : const leveldb_writebatch_t* source) {
365 : 0 : destination->rep.Append(source->rep);
366 : 0 : }
367 : :
368 [ # # ]: 0 : leveldb_options_t* leveldb_options_create() { return new leveldb_options_t; }
369 : :
370 [ # # ]: 0 : void leveldb_options_destroy(leveldb_options_t* options) { delete options; }
371 : :
372 : 0 : void leveldb_options_set_comparator(leveldb_options_t* opt,
373 : : leveldb_comparator_t* cmp) {
374 : 0 : opt->rep.comparator = cmp;
375 : 0 : }
376 : :
377 : 0 : void leveldb_options_set_filter_policy(leveldb_options_t* opt,
378 : : leveldb_filterpolicy_t* policy) {
379 : 0 : opt->rep.filter_policy = policy;
380 : 0 : }
381 : :
382 : 0 : void leveldb_options_set_create_if_missing(leveldb_options_t* opt, uint8_t v) {
383 : 0 : opt->rep.create_if_missing = v;
384 : 0 : }
385 : :
386 : 0 : void leveldb_options_set_error_if_exists(leveldb_options_t* opt, uint8_t v) {
387 : 0 : opt->rep.error_if_exists = v;
388 : 0 : }
389 : :
390 : 0 : void leveldb_options_set_paranoid_checks(leveldb_options_t* opt, uint8_t v) {
391 : 0 : opt->rep.paranoid_checks = v;
392 : 0 : }
393 : :
394 : 0 : void leveldb_options_set_env(leveldb_options_t* opt, leveldb_env_t* env) {
395 [ # # ]: 0 : opt->rep.env = (env ? env->rep : nullptr);
396 : 0 : }
397 : :
398 : 0 : void leveldb_options_set_info_log(leveldb_options_t* opt, leveldb_logger_t* l) {
399 [ # # ]: 0 : opt->rep.info_log = (l ? l->rep : nullptr);
400 : 0 : }
401 : :
402 : 0 : void leveldb_options_set_write_buffer_size(leveldb_options_t* opt, size_t s) {
403 : 0 : opt->rep.write_buffer_size = s;
404 : 0 : }
405 : :
406 : 0 : void leveldb_options_set_max_open_files(leveldb_options_t* opt, int n) {
407 : 0 : opt->rep.max_open_files = n;
408 : 0 : }
409 : :
410 : 0 : void leveldb_options_set_cache(leveldb_options_t* opt, leveldb_cache_t* c) {
411 : 0 : opt->rep.block_cache = c->rep;
412 : 0 : }
413 : :
414 : 0 : void leveldb_options_set_block_size(leveldb_options_t* opt, size_t s) {
415 : 0 : opt->rep.block_size = s;
416 : 0 : }
417 : :
418 : 0 : void leveldb_options_set_block_restart_interval(leveldb_options_t* opt, int n) {
419 : 0 : opt->rep.block_restart_interval = n;
420 : 0 : }
421 : :
422 : 0 : void leveldb_options_set_max_file_size(leveldb_options_t* opt, size_t s) {
423 : 0 : opt->rep.max_file_size = s;
424 : 0 : }
425 : :
426 : 0 : void leveldb_options_set_compression(leveldb_options_t* opt, int t) {
427 : 0 : opt->rep.compression = static_cast<CompressionType>(t);
428 : 0 : }
429 : :
430 : 0 : leveldb_comparator_t* leveldb_comparator_create(
431 : : void* state, void (*destructor)(void*),
432 : : int (*compare)(void*, const char* a, size_t alen, const char* b,
433 : : size_t blen),
434 : : const char* (*name)(void*)) {
435 : 0 : leveldb_comparator_t* result = new leveldb_comparator_t;
436 : 0 : result->state_ = state;
437 : 0 : result->destructor_ = destructor;
438 : 0 : result->compare_ = compare;
439 : 0 : result->name_ = name;
440 : 0 : return result;
441 : : }
442 : :
443 [ # # ]: 0 : void leveldb_comparator_destroy(leveldb_comparator_t* cmp) { delete cmp; }
444 : :
445 : 0 : leveldb_filterpolicy_t* leveldb_filterpolicy_create(
446 : : void* state, void (*destructor)(void*),
447 : : char* (*create_filter)(void*, const char* const* key_array,
448 : : const size_t* key_length_array, int num_keys,
449 : : size_t* filter_length),
450 : : uint8_t (*key_may_match)(void*, const char* key, size_t length,
451 : : const char* filter, size_t filter_length),
452 : : const char* (*name)(void*)) {
453 : 0 : leveldb_filterpolicy_t* result = new leveldb_filterpolicy_t;
454 : 0 : result->state_ = state;
455 : 0 : result->destructor_ = destructor;
456 : 0 : result->create_ = create_filter;
457 : 0 : result->key_match_ = key_may_match;
458 : 0 : result->name_ = name;
459 : 0 : return result;
460 : : }
461 : :
462 : 0 : void leveldb_filterpolicy_destroy(leveldb_filterpolicy_t* filter) {
463 [ # # ]: 0 : delete filter;
464 : 0 : }
465 : :
466 : 0 : leveldb_filterpolicy_t* leveldb_filterpolicy_create_bloom(int bits_per_key) {
467 : : // Make a leveldb_filterpolicy_t, but override all of its methods so
468 : : // they delegate to a NewBloomFilterPolicy() instead of user
469 : : // supplied C functions.
470 : 0 : struct Wrapper : public leveldb_filterpolicy_t {
471 : 0 : static void DoNothing(void*) {}
472 : :
473 [ # # ]: 0 : ~Wrapper() { delete rep_; }
474 : 0 : const char* Name() const override { return rep_->Name(); }
475 : 0 : void CreateFilter(const Slice* keys, int n, std::string* dst) const override {
476 : 0 : return rep_->CreateFilter(keys, n, dst);
477 : : }
478 : 0 : bool KeyMayMatch(const Slice& key, const Slice& filter) const override {
479 : 0 : return rep_->KeyMayMatch(key, filter);
480 : : }
481 : :
482 : : const FilterPolicy* rep_;
483 : : };
484 : 0 : Wrapper* wrapper = new Wrapper;
485 : 0 : wrapper->rep_ = NewBloomFilterPolicy(bits_per_key);
486 : 0 : wrapper->state_ = nullptr;
487 : 0 : wrapper->destructor_ = &Wrapper::DoNothing;
488 : 0 : return wrapper;
489 : : }
490 : :
491 : 0 : leveldb_readoptions_t* leveldb_readoptions_create() {
492 : 0 : return new leveldb_readoptions_t;
493 : : }
494 : :
495 [ # # ]: 0 : void leveldb_readoptions_destroy(leveldb_readoptions_t* opt) { delete opt; }
496 : :
497 : 0 : void leveldb_readoptions_set_verify_checksums(leveldb_readoptions_t* opt,
498 : : uint8_t v) {
499 : 0 : opt->rep.verify_checksums = v;
500 : 0 : }
501 : :
502 : 0 : void leveldb_readoptions_set_fill_cache(leveldb_readoptions_t* opt, uint8_t v) {
503 : 0 : opt->rep.fill_cache = v;
504 : 0 : }
505 : :
506 : 0 : void leveldb_readoptions_set_snapshot(leveldb_readoptions_t* opt,
507 : : const leveldb_snapshot_t* snap) {
508 [ # # ]: 0 : opt->rep.snapshot = (snap ? snap->rep : nullptr);
509 : 0 : }
510 : :
511 : 0 : leveldb_writeoptions_t* leveldb_writeoptions_create() {
512 : 0 : return new leveldb_writeoptions_t;
513 : : }
514 : :
515 [ # # ]: 0 : void leveldb_writeoptions_destroy(leveldb_writeoptions_t* opt) { delete opt; }
516 : :
517 : 0 : void leveldb_writeoptions_set_sync(leveldb_writeoptions_t* opt, uint8_t v) {
518 : 0 : opt->rep.sync = v;
519 : 0 : }
520 : :
521 : 0 : leveldb_cache_t* leveldb_cache_create_lru(size_t capacity) {
522 : 0 : leveldb_cache_t* c = new leveldb_cache_t;
523 : 0 : c->rep = NewLRUCache(capacity);
524 : 0 : return c;
525 : : }
526 : :
527 : 0 : void leveldb_cache_destroy(leveldb_cache_t* cache) {
528 [ # # ]: 0 : delete cache->rep;
529 [ # # ]: 0 : delete cache;
530 : 0 : }
531 : :
532 : 0 : leveldb_env_t* leveldb_create_default_env() {
533 : 0 : leveldb_env_t* result = new leveldb_env_t;
534 : 0 : result->rep = Env::Default();
535 : 0 : result->is_default = true;
536 : 0 : return result;
537 : : }
538 : :
539 : 0 : void leveldb_env_destroy(leveldb_env_t* env) {
540 [ # # # # ]: 0 : if (!env->is_default) delete env->rep;
541 [ # # ]: 0 : delete env;
542 : 0 : }
543 : :
544 : 0 : char* leveldb_env_get_test_directory(leveldb_env_t* env) {
545 [ # # ]: 0 : std::string result;
546 [ # # # # : 0 : if (!env->rep->GetTestDirectory(&result).ok()) {
# # ]
547 : : return nullptr;
548 : : }
549 : :
550 [ # # ]: 0 : char* buffer = static_cast<char*>(malloc(result.size() + 1));
551 [ # # ]: 0 : memcpy(buffer, result.data(), result.size());
552 [ # # ]: 0 : buffer[result.size()] = '\0';
553 : 0 : return buffer;
554 : 0 : }
555 : :
556 : 0 : void leveldb_free(void* ptr) { free(ptr); }
557 : :
558 : 0 : int leveldb_major_version() { return kMajorVersion; }
559 : :
560 : 0 : int leveldb_minor_version() { return kMinorVersion; }
561 : :
562 : : } // end extern "C"
|
